Java之Set接口

1.Set接口：

        Set集合，但凡时实现了Set接口的类都叫做Set集合

2.特点：

        元素无索引，元素不可重复（元素唯一）
        - HashSet集合：实现类    元素存取无序
        - LinkedHashSet集合：实现类   元素存取有序
        - TreeSet集合：实现类   对元素进行排序

3.注意：

      1.Set集合没有特殊的方法，都是使用Collection接口的方法
      2.Set集合没有索引，所以遍历元素的方式只有：增强for循环，或者迭代器

4.HashSet集合存储数据的结构 --- 哈希表

哈希表的结构：
        JDK8以前：数组 + 链表
        JDK8之后：数组 + 链表 + 红黑树
                链表元素个数没有超过8个：数组 + 链表
                链表元素个数超过8个：数组 + 链表 + 红黑树

5.- HastSet集合保证元素唯一的原理 ：

依赖 hashCode() 和 equals() 方法
        1.当存储元素的时候，就会调用该元素的hashCode()方法，计算该元素的哈希值
        2.判断该哈希值对应的位置上，是否有元素
        3.如果该哈希值对应的位置上，没有元素，就直接存储
        4.如果该哈希值对应的位置上，有元素，说明产生了哈希冲突
        5.产生哈希冲突，就得调用该元素的equals()方法，与该位置上的所有元素进行一一比较
                5.1如果比较的时候，有任意一个元素与该元素相同，那么就不存储了
                5.2如果比较完了，没有一个元素与该元素相同，那么就直接存储

6.补充：

Object类：hashCode()和equals()方法；
        equals()方法：Object类中的equals()方法比较的时地址值
        hashSet()方法：Object类中的hashSet()方法时根据地址值计算的哈希值

// 创建一个HashSet集合，限制集合中元素的类型为String类型
HashSet<String> set = new HashSet<>();
//往集合中添加一些元素
set.add("张三");
set.add("李四");
set.add("王五");
set.add("赵六");
set.add("孙七");
set.add("周八");
set.add("张三");
// 遍历打印集合
System.out.println(set);
for (String s : set) {
    System.out.print(s+",");
}
System.out.println();
System.out.println("张三".hashCode());    //哈希值为：774889
System.out.println("李四".hashCode());    //哈希值为：842061
System.out.println("王五".hashCode());    //哈希值为：937065
System.out.println("赵六".hashCode());    //哈希值为：1143448
System.out.println("孙七".hashCode());    //哈希值为：744906
System.out.println("周八".hashCode());    //哈希值为：690691

7.HashSet存储自定义类型元素：重写hashCode()和equals()方法

        在开发中，往往认为2个对象的所有属性值相同的话，就是2个相同的对象

public class Student {

    String name ;
    int age ;

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

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

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

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




class Tests {
    public static void main(String[] args) {

        // 创建HashSet集合对象，限制集合元素的类型为Student类型
        HashSet<Student> set = new HashSet<>();

        //往集合中添加一些元素
        Student s1 = new Student("张三",15);
        Student s2 = new Student("李四",50);
        Student s3 = new Student("王五",17);
        Student s4 = new Student("赵六",41);
        Student s5 = new Student("孙七",19);
        Student s6 = new Student("张三",15);

        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        set.add(s6);

        System.out.println(s1.hashCode() == s6.hashCode());
        System.out.println(s1.equals(s6));

        // 遍历输出集合中的元素
        for (Student student : set) {
            System.out.println(student);
        }

8.总结

        首先根据地址值比较哈希值，一般哈希值都不一样
        可能哈希值也会一样，那么就要比较equals方法
        但是之前Student没有重写equals方法，所以这个时候equals比较的是Object中的equals方法，比较的是地址值
        开发中，一般都认为两个对象的属性值相同的话，那这两个对象就是相同的
... ...
        让哈希值不跟地址值比较，Student重写hashCode方法，让哈希值根据属性计算，可以提高效率
        一开始，两个对象 张三，Studen不重写equals方法，会先根据地址值计算哈希值，两个对象的哈希值有一定几率会放在同一个位置上，那么第二个对象张三就会在第一个对象张三的位置上使用equals方法进行再次比较
        Studen重写了HashCode方法，那么就会genuine属性值计算，那么属性值相同，都对16进行取余数的话，得到的值肯定相同，所以无疑会大大的提高效率
        如果这个时候对象李四得到的哈希值和对象张三得到的哈希值一样的话，我们还会使用equals方法来比较，因此我们需要给Student类中重写equals方法以及hashCode方法

9.LinkedHashSet集合

        元素存取有序，元素无索引，元素不可重复（唯一）
                采用哈希表 + 链表 结构，由哈希表保证元素唯一，由链表保证元素存取有序

// 创建一个LinkedHashSet集合，限制集合中元素的类型为Integer类型
LinkedHashSet<Integer> set = new LinkedHashSet<>();
// 往集合中添加一些元素
set.add(300);
set.add(200);
set.add(900);
set.add(100);
set.add(800);
set.add(300);
System.out.println(set);  //  [300, 200, 900, 100, 800]

10.TreeSet集合：

        元素无索引，元素唯一，堆元素进行排序
  通过构造方法实现排序：
        - public TreeSet()  根据其元素的自然排序进行排序
                默认排序规则：集合元素所属的类需要实现Comparable接口，重写compareTo方法，在compareTo方法中制定默认排序规则
        - public TreeSet(Comparator<E> comparator)  根据制定的比较器进行排序
                指定排序规则：通过传入Comparator接口的实现类对象，在实现类对象中重写compareTo方法，在compareTo方法中指定排序规则

// 按照默认规则排序
TreeSet<Integer> set = new TreeSet<>();
set.add(300);
set.add(200);
set.add(900);
set.add(100);
set.add(800);
set.add(300);
System.out.println(set);    //  [100, 200, 300, 800, 900]
TreeSet<Integer> set1 = new TreeSet<>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1; //降序
    }
});
set1.add(300);
set1.add(200);
set1.add(900);
set1.add(100);
set1.add(800);
set1.add(300);
System.out.println(set1);   //  [900, 800, 300, 200, 100]