标签：Map return LinkedList 实现 age id int public name

容器

1. LinkedList实现类

LinkedList实现类的数据是有序可重复的，底层结构式双向链表。特点是增删效率较高，根据索引查询、遍历、修改效率低。

应用场景：在大量做增删，少量做查询的情况下适合使用LinkedList

LinkedList中新增了一些操作链表头尾的方法

常用方法：

import java.util.LinkedList;
public class LinkedListDemo01 {
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<>();
        link.add("haha");
        link.add("hehe");
        link.add("heihei");
        link.add("xixi");
        System.out.println(link);
        //add(int index, E element) 将指定元素插入此列表中的指定位置
        link.add(2,"lala");
        System.out.println(link);
        //addFirst(E e) 在此列表的开头插入指定的元素
        //addLast(E e) 将指定的元素追加到此列表的末尾
        link.addFirst("first");
        link.addLast("last");
        System.out.println(link);
        //element() 检索但不删除此列表的头部（第一个元素）
        System.out.println(link.element());
        //get(int index) 返回此列表中指定位置的元素
        System.out.println(link.get(3));
        //poll() 检索并删除此列表的头部（第一个元素）
        link.poll();
        System.out.println(link);
        //pollFirst() 检索并删除此列表的第一个元素，如果此列表为空，则返回 null
        //pollLast() 检索并删除此列表的最后一个元素，如果此列表为空，则返回 null
        link.pollFirst();
        link.pollLast();
        System.out.println(link);
        //set(int index, E element) 用指定的元素替换此列表中指定位置的元素
        link.set(2,"tihuan");
        System.out.println(link);
    }
}

2. 添加比较器

使用Arrays工具类给存储自定义类型数据的数组进行排序，使用Lambda表达式的方式定义外部比较器。代码如下：

//自定义User类，将数据存于User类型的数组，使用Arrays.sort()方法对这个数组做排序，要求按照用户编号降序排序/按照工资做升序排序
import java.util.Arrays;
import java.util.Comparator;
public class Demo02 {
    public static void main(String[] args) {
        User u1 = new User(101,"张三",3000);
        User u2 = new User(103,"李四",2000);
        User u3 = new User(102,"王五",4000);
        User[] arr = {u1,u2,u3};
		//定义内部比较器类
        Comparator<User> com = new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o2.getUid()-o1.getUid();
            }
        };

        //转为Lambda表达式
        com = (User o1, User o2)->{
            return o2.getUid()-o1.getUid();
        };
		//使用Lambda表达式排序
        Arrays.sort(arr,(User o1, User o2)->{
            return o2.getUid()-o1.getUid();
        });
		//使用Lambda表达式排序
        Arrays.sort(arr,(User o1, User o2)->{
            return o1.getSal()-o2.getSal();
        });

        System.out.println(Arrays.toString(arr));
    }
}

class User{
    private int uid;
    private String name;
    private int sal;

    public User() {
    }

    public User(int uid, String name, int sal) {
        this.uid = uid;
        this.name = name;
        this.sal = sal;
    }

    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSal() {
        return sal;
    }

    public void setSal(int sal) {
        this.sal = sal;
    }

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", name='" + name + '\'' +
                ", sal=" + sal +
                '}';
    }
}

3. HashSet实现类

HashSet实现类的数据是无序，不可重复的。底层结构是哈希表（数组+链表+红黑树）。特点是做查询，增删效率较高。

HashSet与TreeSet之间进行选择时，如果想要数据存储的时候默认升序或者降序使用TreeSet，否则建议选择HashSet。

通过HashSet存储自定义引用数据类型的数据时如果要去重，需要在自定义引用类型中重写hashcode与equals方法，根据内容进行比较。

HashSet常用方法和遍历方式：

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetDemo03 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("赵六");
        set.add("哈哈");
        System.out.println(set);
        set.remove("哈哈");
        System.out.println(set);
        //遍历方式
        //增强for
        for (String s:set){
            System.out.println(s);
        }
        //iterator迭代器
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

使用HashSet实现去重问题：

import java.util.HashSet;
import java.util.Objects;

public class HashSetDemo04 {
    public static void main(String[] args) {
        Person p1 = new Person(101,"张三",20);
        Person p2 = new Person(102,"李四",18);
        Person p3 = new Person(103,"王五",21);
        Person p4 = new Person(101,"张三",20);

        HashSet<Person> hash = new HashSet<>();
        hash.add(p1);
        hash.add(p2);
        hash.add(p3);
        hash.add(p4);
        
        System.out.println(hash);//[Person{id=102, name='李四', age=18}, Person{id=101, name='张三', age=20}, Person{id=103, name='王五', age=21}]
    }
}

class Person{
    private int id;
    private String name;
    private int age;

    public Person() {
    }

    public Person(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return id == person.id &&
                age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, age);
    }
}

4. Map接口

Map<K,V>接口存储键值对数据，每一个key对应一个value，key是唯一的无序的，value是无序可重复的。

常用方法和遍历方式：

import java.util.*;

public class MapDemo {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        //put(K key, V value) 将指定的值与此映射中的指定键相关联
        map.put(101,"张三");
        map.put(104,"李四");
        map.put(102,"王五");
        map.put(103,"赵六");
        System.out.println(map);
        //get(Object key) 返回指定键映射到的值，如果此映射不包含键的映射
        System.out.println(map.get(103));
        //remove(Object key) 如果存在，则从该映射中移除键的映射
        map.remove(103);
        System.out.println(map);

        //三种遍历方式
        //1. Set<K> keySet() 返回此映射中包含的键的Set视图 可以遍历得到键值对
        Set<Integer> set1 = map.keySet();
        for (int a:set1){
            System.out.println(a+"-->"+map.get(a));
        }
        //2. Collection<V> values() 返回此映射中包含的值的Collection视图 只能遍历得到value
        Collection<String> col = map.values();
        Iterator<String> it = col.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //3. Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射的Set视图 可以遍历得到键值对
        Set<Map.Entry<Integer,String>> set2 = map.entrySet();
        for (Map.Entry<Integer,String> entrys:set2){
            System.out.println(entrys.getKey()+"-->"+entrys.getValue());
        }
    }
}

5. HashMap实现类

与HashSet相同，HashMap的底层结构也为红黑树。HashMap存储的key如果为自定义引用数据类型，为了去重，key类型中要求重写hashcode与equals方法。

代码：

import java.util.HashMap;
import java.util.Objects;

public class HashMapDemo {
    public static void main(String[] args) {
        Student s1 = new Student(104,"张三",24);
        Student s2 = new Student(102,"李四",25);
        Student s3 = new Student(103,"王五",22);
        Student s4 = new Student(101,"赵六",26);
        //将自定义类作为key
        HashMap<Student, String> hash = new HashMap<>();
        hash.put(s1,"班长");
        hash.put(s2,"副班长");
        hash.put(s3,"组长");
        hash.put(s4,"副组长");
        System.out.println(hash);
    }
}
//自定义类
class Studet{
    private int id;
    private String name;
    private int age;

    public Studet() {
    }

    public Studet(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "Studet{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
	//重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Studet studet = (Studet) o;
        return id == studet.id &&
                age == studet.age &&
                Objects.equals(name, studet.name);
    }
	//重写hashCode方法
    @Override
    public int hashCode() {
        return Objects.hash(id, name, age);
    }
}

6. Hash表存储原理

Hash表中Node节点数组存储节点数据，节点包含key，value，hash，next。Hash表的存储原理：

• put(key,value)存储键值对类型的数据，根据key计算hash值，确定索引的位置
• 找到Node数组中的指定索引位置，判断当前位置中是否存在数据，没有则直接构建一个Node节点对象 new Node(key,value,hash,null)，放入数组。如果已经存在值，就比较每一个Node的key与我当前要存储的key是否相等，相等value值覆盖，不相等则继续判断，最后数据放入链表的最后

Hash表的初识容量为16，加载因子为0.75（扩容的临界点），最大容量为2^30，扩容后的新数组容量为原容量的2倍。

标签：Map,return,LinkedList,实现,age,id,int,public,name
来源： https://blog.csdn.net/gaozhen666/article/details/115583800

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。