集合的其他几个类型

Set

HashSet（底层数据结构是哈希表，元素无序(存取顺序不一致)且唯一）

此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。
合理的重写hashCode方法的作用：1.确定元素节点在哈希表中的存的位置，2，减少调用equals方法()，重写equals方法 当节点的索引相同时，去比较内容。

JDK1.8 HashSet的数据结构是 数组跟链表和二叉树,因此唯一性靠重写·hashCode 和 equals() 方法来保证的。

 @Override
    public int hashCode() {
                //张三 20  +  30*11   =50
                //张三 20  +  30*11   =50
                //李四 10 +   24*11   34
                //赵六 24  +   10*11   34
        return name.hashCode()+age*11;
    }
    @Override
    public boolean equals(Object obj) {
        System.out.println(this+"==="+obj);
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof Student)) {
            return false;
        }
        Student student = (Student) obj;
        return this.name.equals(student.name) && this.age == student.age;
    }

LinkedHashSet

LinkedHashSet 底层数据结构是 链表和哈希表 链表保证元素有序，哈希表保证唯一
LinkedHashSet 元素有序且唯一 注意，此实现不是同步的 线程不安全 效率高

TreeSet

A: TreeSet集合的特点: 元素唯一,并且可以对元素进行排序
排序:
a: 自然排序
b: 使用比较器排序
到底使用的是哪一种的排序取决于,构造方法.
注意：使用TreeSet集合进行元素的自然排序，那么对元素有要求，要求这个元素
必须实现Comparable接口 否则无法进行自然排序
保证元素的唯一性是靠compareTo,根据此方法的返回值的正负0 来决定元素放置到树结构的位置，以及不往里面放。
采用空参构造创建TreeSet集合就是

public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Student student) {
        //System.out.println("会调用比较方法");
        //如果年龄一样，还得比较姓名
        int num = this.age - student.age;
        //if(num==0){
        //    num=this.name.compareTo(student.name);
        //}
        int num2 = num == 0 ? this.name.compareTo(student.name) : num;
        return num2;
    }
}

上面就是自然排序，实现Comparable接口并重写Compare方法。

采用比较器排序：你使用有参构造，参数就会要一个比较器

  MyComparator myComparator = new MyComparator();
        TreeSet<Student> set = new TreeSet<>(myComparator);
        public class MyComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        //如果年龄一样，还得比较姓名
        int num = s1.getAge()- s2.getAge();
        int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
        return num2;
    }
}
另一种写法
 TreeSet<Student> set = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getName().length() - s2.getName().length();
                int num2=num==0?s1.getName().compareTo(s2.getName()):num;
                int num3=num2==0?s1.getAge()-s2.getAge():num2;
                return num3;
            }
        });

// 需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
  public static void main(String[] args) {
        Random random = new Random();
        HashSet<Integer> set = new HashSet<>();
        while (set.size()<10){
            int i = random.nextInt(20)+1;
            set.add(i);
        }
        System.out.println(set);
    }
}