Set集合的存储特点、实现类、Set集合的遍历方式以及哈希表的去重原理，书写TresSet排序的规则

Collection

• 所有集合都是由Collection或Map派生

• Collection是List和Set的父接口

特点

1. 存放List和Set的共有内容

2. 没有直接实现类

Set的存储特点

无序、无下标、元素不可重复

Set的常用实现类

1. HashSet

   • JDK1.2 底层哈希表（数组+链表）实现 线程不安全，效率高

2. LinkedHashSet

   • JDK1.2 是HashSet的子类，底层哈希表实现 线程不安全，效率高

3. TreeSet

   • JDK1.2 底层红黑树实现，是SortedSet的实现类 线程不安全，效率高

Set的常用方法

• 全部来自于Collection父接口，没有独有方法

Set的创建

• 建议使用多态

Set<泛型> 集合名=new 实现类名<>();

Set的遍历

1. 迭代器遍历

2. 外遍历forEach

3. 自遍历forEach

​
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
​
public class Test {
    public static void main(String[] args) {
        //创建一个存放整型的set集合
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(22);
        set.add(40);
        set.add(88);
        set.add(88);
​
        //迭代器遍历
        //获取集合的迭代器
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()) {//判断是否存在下一元素
            //指针后移，获取下一元素
            System.out.print(it.next()+"  ");;
        }
        System.out.println();
​
        //外遍历
        for (Integer i : set) {
            System.out.print(i+"  ");
        }
        System.out.println();
​
        //自遍历
        set.forEach(i-> System.out.print(i+"  "));
​
    }
​
}
​

哈希表的去重过程

添加元素时，会先调用其hashCode()获取哈希码值

通过哈希码值%数组长度得到存放下标

如果下标位置未存有元素，则直接存放

如果下标位置存有元素，则调用其equals()与该位置所有元素进行值的比较

都不相同，继续链表存放

如有相同，则直接舍弃当前添加元素

使用

1. HashSet和LinkedHashSet在存放自定义类型时，必须重写hashCode()和equals()才能保证去重

2. LinkedHashSet能够保证元素存入和取出的顺序一致

3. TreeSet能够对元素进行默认的升序排序

   • 必须对自定义类型书写排序规则，否则执行报错

     1. 实现Comparable接口，重写compareTo()

        • 规则：想对谁排序，就让谁实现

        • 原理：让当前对象this和参数o进行比较，根据比较结果书写返回值

        • 返回值规则：

          • 从小到大：this的值>o的值返回正数，this的值<o的值返回负数

          • 从大到小：this的值>o的值返回负数，this的值<o的值返回正数

          • 相等返回0

          package com.bz.entity;
          ​
          public class Student implements Comparable<Student>{
              private String name;
              private int age;
              private double score;
              //省略getter、setter、构造
          ​
              @Override
              public int compareTo(Student o) {
                  //根据学生年龄从小到大排序
                 // return this.age - o.age;
                  //根据学生年龄从大到小排序
                  return o.age - this.age;
              }
          }
          ​

     2. 实现Comparator接口，重写compare()

        • 规则：在集合创建处的小括号内传入该接口的实现类对象即可

        Set<Student> set = new TreeSet<>(new Comparator<Student>() {
                    @Override
                    public int compare(Student o1, Student o2) {
                        //根据学生年龄从小到大
                        return o1.getAge() - o2.getAge();
                    }
                });
        //lambda简化：
        Set<Student> set = new TreeSet<>((o1,o2)-> o1.getAge()-o2.getAge());

        • 当排序规则出现冲突时，优先执行Comparator

        • 实际开发中，更推荐使用比较器Comparator，因为其更符合代码职责分离的原则

   • TreeSet是在compareTo()或compare()返回值为0时去重