Java 集合进阶（Set）

朴灿烈づ我的快乐病毒、 2024-03-02 08:05 58阅读 0赞

### 一、Set系列集合 ###

#### 1、认识Set集合的特点 ####

Set集合是属于Collection体系下的另一个分支，它的特点如下图所示

**Collection集合体系**

![74ad9f38a7ca4b9988b75fcc4935f5e2.png][]

**Set系列集合特点**

无序：存取顺序不一致。

不重复：可以去除重复。

无索引：没有带有索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。

**Set集合实现类特点**

HashSet：无序、不重复、无索引。

LinkedHashSet：**有序**、不重复、无索引。

TreeSet：**排序**、不重复、无索引。

Set集合的功能上基本与Collection的API一致。代码演示：

/**
     * Set系列集合特点：无序：添加数据的顺序和获取出的数据顺序不一致；不重复，无索引；
     *  * HashSet：无序、不重复、无索引。
     *  * LinkedHashSet：有序、不重复、无索引。
     *  * TreeSet：排序、不重复、无索引。
     *
     * 注意：Set要用到的常用方法，基本就是Collection提供的！！
     *      自己几乎没有额外新增一些常用功能！
     */
    public class SetTest1 {
        public static void main(String[] args) {
            // 目标：整体了解一下Set系列集合的特点。
            // 1、创建一个Set集合的对象
            Set<Integer> set = new HashSet<>(); // 创建了一个HashSet的集合对象。一行经典代码 HashSet：无序、不重复、无索引。
            set.add(666);
            set.add(555);
            set.add(555);
            set.add(888);
            set.add(888);
            set.add(777);
            set.add(777);
            System.out.println(set); // 多运行几次，无序的顺序一旦定下来就不变了 [888, 777, 666, 555]
    
            System.out.println("-------------------------------------");
    
            Set<Integer> set1 = new LinkedHashSet<>(); // 有序、不重复、无索引。
            set1.add(666);
            set1.add(555);
            set1.add(555);
            set1.add(888);
            set1.add(888);
            set1.add(777);
            set1.add(777);
            System.out.println(set1); // [666, 555, 888, 777]
    
            System.out.println("-------------------------------------");
    
            Set<Integer> set2 = new TreeSet<>(); // 可排序(默认升序)、不重复、无索引。
            set2.add(666);
            set2.add(555);
            set2.add(555);
            set2.add(888);
            set2.add(888);
            set2.add(777);
            set2.add(777);
            System.out.println(set2); // [555, 666, 777, 888]
        }
    }

#### 2、Set集合底层原理 ####

##### 2.1 HashSet集合底层原理 #####

HashSet集合底层是基于哈希表实现的，哈希表根据JDK版本的不同，也是有点区别的

>  *  JDK8以前：哈希表 = 数组+链表
>  *  JDK8以后：哈希表 = 数组+链表+红黑树

![b63a544f3e6b471195965945596fae5d.png][]

我们发现往HashSet集合中存储元素时，底层调用了元素的两个方法：一个是hashCode方法获取元素的hashCode值（哈希值）；另一个是调用了元素的equals方法，用来比较新添加的元素和集合中已有的元素是否相同。

*  有新添加元素的hashCode值和集合中以后元素的hashCode值相同、新添加的元素调用equals方法和集合中已有元素比较结果为true, 才认为元素重复。
 *  如果hashCode值相同，equals比较不同，则以链表的形式连接在数组的同一个索引为位置（如上图所示）

在JDK8开始后，为了提高性能，当链表的长度超过8时，就会把链表转换为红黑树，如下图所示：

![df098c1f86ed480381b63415818d0e7e.png][]

/**
     * HashSet集合的底层原理
     *      1.为什么添加的元素无序、不重复、无索引？
     * 先了解一个前置知识：哈希值！
     * 哈希值
     *      就是一个int类型的数值，Java中每个对象都有一个哈希值。
     *      Java中的所有对象，都可以调用Object类提供的hashCode方法，返回该对象自己的哈希值。
     *      public int hashCode()：返回对象的哈希码值。
     *
     * 对象哈希值的特点：
     *      同一个对象多次调用hashCode()方法返回的哈希值是相同的。
     *      不同的对象，它们的哈希值一般不相同，但也有可能相同(哈希碰撞)。
     *      int(-21亿 ~ 21亿)，如果创建45亿个对象，就会有哈希碰撞。
     *
     * HashSet集合的底层原理
     *      * 基于哈希表实现的。
     *      * 哈希表是一种增删改查数据，性能都较好的数据结构。
     * 哈希表
     *      *JDK8之前，哈希表 = 数组 + 链表
     *      *JDK8开始，哈希表= 数组 + 链表 + 红黑树
     * JDK8之前HashSet集合的底层原理，基于哈希表：数组 + 链表
     * [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null]
     *   0     1     2     3     4     5     6     7     8     9    10     11    12    13    14    15
     *   ① 创建要给默认长度16的数组，默认加载因子为0.75，数组名table
     *      如果数组快占满了，加载因子会扩容(16 * 0.75 = 12)
     *   ② 使用元素的哈希值对数组的长度求余，计算出应存入的位置
     *   ③ 判断当前位置是否为null，如果为null直接存入
     *   ④ 如果不为null，表示有元素，则调用equals方法比较
     *      相等，则不存；不相等，则存入数组
     *      * JDK8之前，新元素存入数组，占老元素位置，老元素挂下面
     *      * JDK8开始之后，新元素直接挂在老元素下面
     *
     * JDK8开始HashSet集合的底层原理，基于哈希表：数组 + 链表 + 红黑树
     *    [null, null, null, null, 20, null, null, null, null, null, null, null, null, null, null, null]
     *      0     1     2     3   /4\   5     6     7     8     9    10     11    12    13    14    15
     *                           18 23(小的挂左边，大的挂右边)
     *    JDK8开始，当链表长度超过8，且数组长度>=64时，自动将链表转成红黑树
     * 小结：JDK8开始后，哈希表中引入了红黑树后，进一步提高了操作数据的性能。
     */
    public class SetTest2 {
        public static void main(String[] args) {
            Student s1 = new Student("蜘蛛精", 25, 169.5);
            Student s2 = new Student("紫霞", 22, 166.5);
            System.out.println(s1.hashCode()); // -281121023
            System.out.println(s1.hashCode()); // -281121023
            System.out.println(s2.hashCode()); // 2072149404
    
            // 哈希碰撞
            String str1 = new String("abc");
            String str2 = new String("acD");
            System.out.println(str1.hashCode()); // 96354
            System.out.println(str2.hashCode()); // 96354
        }
    }

##### 2.2 HashSet去重原理 #####

前面我们学习了HashSet存储元素的原理，依赖于两个方法：一个是hashCode方法用来确定在底层数组中存储的位置，另一个是用equals方法判断新添加的元素是否和集合中已有的元素相同。

要想保证在HashSet集合中没有重复元素，我们需要重写元素类的hashCode和equals方法。比如以下面的Student类为例，假设把Student类的对象作为HashSet集合的元素，想要让学生的姓名和年龄相同，就认为元素重复。

![227f16489b3a4a83a3512b6ebaa7f07c.png][]

> **案例：Set集合去重复**
> 
> **需求：**
> 
> 创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合，要求：学生对象的成员变量值相同，我们就认为是同一个对象。
> 
> **分析：**
> 
> 1、定义学生类，创建HashSet集合对象，创建学生对象。
> 
> 2、把学生添加到集合。
> 
> 3、在学生类中重写两个方法：hashCode() 和 equals()，自动生成即可。
> 
> 4、遍历集合（增强for）

public class Student implements Comparable<Student>{
        private String name;
        private int age;
        private double height;
    
        // this o
        @Override
        public int compareTo(Student o) {
            // 如果认为左边对象大于右边对象返回正整数
            // 如果认为左边对象小于右边对象返回负整数
            // 如果认为左边对象等于右边对象返回0
            // 需求：按照年龄升序排序
            return this.age - o.age;
        }
    
        public Student() {
        }
    
        public Student(String name, int age, double height) {
            this.name = name;
            this.age = age;
            this.height = height;
        }
    
        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;
        }
    
        public double getHeight() {
            return height;
        }
    
        public void setHeight(double height) {
            this.height = height;
        }
    
        // 只要两个对象内容一样就返回true
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Student student)) return false;
            return getAge() == student.getAge() && Double.compare(student.getHeight(), getHeight()) == 0 && Objects.equals(getName(), student.getName());
        }
    
        // 只要两个对象内容一样，返回的哈希值就是一样的。
        @Override
        public int hashCode() {
            // 姓名 年龄 身高计算哈希值
            return Objects.hash(getName(), getAge(), getHeight());
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", height=" + height +
                    '}';
        }
    }

接着，写一个测试类，往HashSet集合中存储Student对象。

/**
     * 深入理解HashSet集合去重复的机制。
     *      HashSet集合默认不能对内容一样的两个不同对象去重复！
     *          比如内容一样的两个学生对象存入到HashSet集合中去，HashSet集合是不能去重复的！
     *          如何让HashSet集合能够实现对内容一样的两个不同对象也能去重复？？？
     *          重写hashCode方法和equals方法
     */
    public class SetTest3 {
        public static void main(String[] args) {
            Set<Student> students = new HashSet<>();
            Student s1 = new Student("至尊宝", 28, 169.6);
            Student s2 = new Student("蜘蛛精", 23, 169.6);
            Student s3 = new Student("蜘蛛精", 23, 169.6);
            System.out.println(s2.hashCode());
            System.out.println(s3.hashCode());
            Student s4 = new Student("牛魔王", 48, 169.6);
            students.add(s1);
            students.add(s2);
            students.add(s3);
            students.add(s4);
            System.out.println(students);
        }
    }

打印结果如下，我们发现存了两个蜘蛛精，当时实际打印出来只有一个，而且是无序的。

> Student\{name='牛魔王', age=48, height=169.6\}  
> Student\{name='至尊宝', age=20, height=169.6\}  
> Student\{name='蜘蛛精', age=23, height=169.6\}

#### 3、LinkedHashSet底层原理 ####

LinkedHashSet它底层采用的是也是哈希表结构，只不过额外新增了一个双向链表来维护元素的存取顺序。如下图所示：

![293e7993a313489d8c9cc395682794be.png][]

每次添加元素，就和上一个元素用双向链表连接一下。第一个添加的元素是双向链表的头节点，最后一个添加的元素是双向链表的尾节点。

把上个案例中的集合改成LinkedList集合：

public class Test{
        public static void main(String[] args){
            Set<Student> students = new LinkedHashSet<>();
            Student s1 = new Student("至尊宝",20, 169.6);
            Student s2 = new Student("蜘蛛精",23, 169.6);
            Student s3 = new Student("蜘蛛精",23, 169.6);
            Student s4 = new Student("牛魔王",48, 169.6);
            
            students.add(s1);
            students.add(s2);
            students.add(s3);
            students.add(s4);
            
            for(Student s : students){
                System.out.println(s);
            }
        }
    }

打印结果如下：

> Student\{name='至尊宝', age=20, height=169.6\}  
> Student\{name='蜘蛛精', age=23, height=169.6\}  
> Student\{name='牛魔王', age=48, height=169.6\}

#### 4、TreeSet集合 ####

##### 4.1 TreeSet集合概述 #####

TreeSet集合的特点是可以对元素进行排序，但是必须指定元素的排序规则。

如果往集合中存储String类型的元素，或者Integer类型的元素，它们本身就具备排序规则，所以直接就可以排序。

Set<Integer> set1= new TreeSet<>();
    set1.add(8);
    set1.add(6);
    set1.add(4);
    set1.add(3);
    set1.add(7);
    set1.add(1);
    set1.add(5);
    set1.add(2);
    System.out.println(set1); //[1,2,3,4,5,6,7,8]
    
    Set<Integer> set2= new TreeSet<>();
    set2.add("a");
    set2.add("c");
    set2.add("e");
    set2.add("b");
    set2.add("d");
    set2.add("f");
    set2.add("g");
    System.out.println(set1); //[a,b,c,d,e,f,g]

如果往TreeSet集合中存储自定义类型的元素，比如说Student类型，则需要我们自己指定排序规则，否则会出现异常。

//创建TreeSet集合，元素为Student类型
    Set<Student> students = new TreeSet<>();
    
    //创建4个Student对象
    Student s1 = new Student("至尊宝",20, 169.6);
    Student s2 = new Student("紫霞",23, 169.8);
    Student s3 = new Student("蜘蛛精",23, 169.6);
    Student s4 = new Student("牛魔王",48, 169.6);
    
    //添加Studnet对象到集合
    students.add(s1);
    students.add(s2);
    students.add(s3);
    students.add(s4);
    System.out.println(students);

此时运行代码，会直接报错。原因是TreeSet不知道按照什么条件对Student对象来排序。

![13547856459144a590149eb63e6b77cd.png][]

##### 4.2 TreeSet集合特点 #####

不重复、无索引、可排序。

可排序：按照元素的大小默认升序（由小到大）排序。

TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都比较好。

**注意：TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序。**

##### 4.3 TreeSet集合默认的规则 #####

对于数值类型：Integer、Double，官方默认按照大小进行升序排序。

对于字符串类型：默认按照首字符的编号升序排序。

对于自定义类型，如Student对象，TreeSet无法直接排序。

**结论：想要使用TreeSet存储自定义类型，需要制定排序规则。**

##### 4.4 自定义排序规则 #####

> TreeSet集合存储对象的时候有2种方式可以设计自定义比较规则：
> 
> 第一种：让元素的类实现Comparable接口，重写compareTo方法。
> 
> 第二种：在创建TreeSet集合时，通过构造方法传递Compartor比较器对。

*  **排序方式1：让元素的类实现Comparable接口，重写compareTo方法。**

//第一步：先让Student类，实现Comparable接口
    //注意：Student类的对象是作为TreeSet集合的元素的
    public class Student implements Comparable<Student>{
        private String name;
        private int age;
        private double height;
    	//无参数构造方法
        public Student(){}
        //全参数构造方法
        public Student(String name, int age, double height){
            this.name=name;
            this.age=age;
            this.height=height;
        }
        //...get、set、toString()方法自己补上..
        
        //第二步：重写compareTo方法
        //按照年龄进行比较，只需要在方法中让this.age和o.age相减就可以。
        /*
        原理：
        在往TreeSet集合中添加元素时，add方法底层会调用compareTo方法，根据该方法的
        结果是正数、负数、还是零，决定元素放在后面、前面还是不存。
        */
        @Override
        public int compareTo(Student o) {
            //this：表示将要添加进去的Student对象
            //o: 表示集合中已有的Student对象
            return this.age-o.age;
        }
    }

此时，再运行测试类，结果如下 ：

> Student\{name='至尊宝', age=20, height=169.6\}  
> Student\{name='紫霞', age=20, height=169.8\}  
> Student\{name='蜘蛛精', age=23, height=169.6\}  
> Student\{name='牛魔王', age=48, height=169.6\}

*  **排序方式2：在创建TreeSet集合时，通过构造方法传递Compartor比较器对。**

//创建TreeSet集合时，传递比较器对象排序
    /*
    原理：当调用add方法时，底层会先用比较器，根据Comparator的compare方是正数、负数、还是零，决定谁在后，谁在前，谁不存。
    */
    //下面代码中是按照学生的年龄升序排序
    Set<Student> students = new TreeSet<>(new Comparator<Student>{
        @Override
        public int compare(Student o1, Student o2){
            //需求：按照学生的身高排序
            return Double.compare(o1,o2); 
        }
    });
    
    //创建4个Student对象
    Student s1 = new Student("至尊宝",20, 169.6);
    Student s2 = new Student("紫霞",23, 169.8);
    Student s3 = new Student("蜘蛛精",23, 169.6);
    Student s4 = new Student("牛魔王",48, 169.6);
    
    //添加Studnet对象到集合
    students.add(s1);
    students.add(s2);
    students.add(s3);
    students.add(s4);
    System.out.println(students);

**两种方式中，关于返回值的规则：**

如果认为第一个元素大于第二个元素就返回正整数即可。

如果认为第一个元素小于第二个元素就返回负整数即可。

如果认为第一个元素等于第二个元素返回0即可，此时TreeSet集合只会保留一个元素，认为两者重复。

**注意：如果TreeSet集合存储的对象有实现比较规则，集合也自带比较器，默认使用集合自己带的比较器排序。**

/**
     * 目标：掌握TreeSet集合的使用。
     * 特点：不重复、无索引、可排序(默认升序排序，按照元素的大小，由小到排序)
     *      底层是基于红黑树实现的排序。
     * 注意：
     *      对于数值类型：Integer，Double，默认按照数值本身的大小进行升序排序。
     *      对于字符串类型：默认按照首字母的而编号升序排序。
     *      对于自定义类型，如Student对象，TreeSet默认是无法直接排序的。
     *
     * 自定义排序规则
     *      TreeSet集合存储自定义类型的对象时，必须指定排序规则，支持如下两种方式来指定比较规则。
     *    方式一：
     *          让自定义的类(如学生类)实现Comparable接口，重写里面的compareTo方法来指定比较规则。
     *    方式二：
     *          通过调用TreeSet集合有参数构造器，可以设置Comparator对象(比较器对象)，用于指定比较规则。
     *          public TreeSet(Comparator<? super E> comparator)
     *  两种方式中，关于返回值的规则：
     *      * 如果认为第一个元素 > 第二个元素，返回正整数即可。
     *      * 如果认为第一个元素 < 第二个元素，返回负整数即可。
     *      * 如果认为第一个元素 = 第二个元素，返回0即可，此时TreeSet集合只会保留一个元素，认为两者重复。
     *  注意：
     *      如果类本身有实现Comparable接口，TreeSet集合同时也自带比较器，默认使用集合自带的比较器排序。
     */
    public class SetTest4 {
        public static void main(String[] args) {
            Set<Integer> set1 = new TreeSet<>();
            set1.add(6);
            set1.add(5);
            set1.add(5);
            set1.add(7);
            System.out.println(set1);
    
            System.out.println("-------------------------");
    
            // TreeSet就近选择自己自带的比较器对象进行排序
    //        Set<Student> students = new TreeSet<>(new Comparator<Student>() {
    //            @Override
    //            public int compare(Student o1, Student o2) {
    //                // 需求：按照身高升序排序
    //                return Double.compare(o1.getHeight(), o2.getHeight());
    //            }
    //        });
    
            // 简化代码
            Set<Student> students = new TreeSet<>((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()));
    
            students.add(new Student("蜘蛛精", 23, 169.7));
            students.add(new Student("紫霞", 22, 169.8));
            students.add(new Student("至尊宝", 26, 165.5));
            students.add(new Student("牛魔王", 22, 183.5));
            System.out.println(students); // ClassCastException：Student cannot be cast to class java.lang.Comparable
        }
    }

### 二、总结Collection集合 ###

![d4c72058d01845299a9f68767f4260b6.png][]

**总结：**

1、如果希望元素可以重复，又有索引，索引查询要快？

**用ArrayList集合，基于数组的。（用的最多）**

2、如果希望元素可以重复，又有索引，增删首尾操作快？

**用LinkedList集合，基于链表的。**

3、如果希望增删改查都快，但是元素不重复、无序、无索引？

**用HashSet集合，基于哈希表的。**

4、如果希望增删改查都快，但是元素不重复、有序、无索引？

**用LinkedHashSet，基于哈希表和双链表。**

5、如果要对对象进行排序？

**用TreeSet集合，基于红黑树。后续也可以用List集合实现排序。**

### 三、补充知识：可变参数 ###

> **什么是可变参数：**
> 
>  *  **可变参数是一种特殊的形式参数，定义在方法、构造器的形参列表处，它可以让方法接收多个同类型的实际参数。**
>  *  **可变参数在方法内部，本质上是一个数组。**
> 
> **格式：**数据类型...参数名称

代码演示：

/**
     * 目标：认识可变参数，掌握其作用。
     * 前置知识 —— 可变参数
     * 可变参数：
     *      就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型...参数名称；
     * 可变参数的特点和好处：
     *      特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。
     *      好处：常常用来灵活的接收数据。
     */
    public class ParamTest {
        public static void main(String[] args) {
            // 特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。
            test(); // 不传数据
            test(10); // 传输一个数据给它
            test(10, 20, 30); // 传输多个数据给它
            test(new int[]{10, 20, 30, 40}); // 传输一个数组给可变参数
        }
    
        // 注意事项1：一个形参列表中，只能有一个可变参数。
        // 注意事项2：可变参数必须放在形参列表的最后面。
        public static void test(int... nums) {
            // 可变参数在方法内部，本质就是一个数组。
            System.out.println(nums.length);
            System.out.println(Arrays.toString(nums));
            System.out.println("-----------------------------------");
        }
    }

**可变参数的作用**

接收参数非常灵活，方便。可以不接收参数，可以接收1个或者多个参数，也可以接收一个数组。

最后还有一些错误写法，大家写代码时注意一下，不要这么写哦！！！

> **注意事项：** 
> 
>  *  一个形参列表中，只能有一个可变参数；否则会报错。
>  *  一个形参列表中如果多个参数，可变参数需要写在最后；否则会报错。

![84925d77a46443fc91ba3cb84c0b5c56.png][]

[74ad9f38a7ca4b9988b75fcc4935f5e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/4e5611c1c516429ca94f238e43eb0f16.png
[b63a544f3e6b471195965945596fae5d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/fe5da7d4413e45a69085f4cf4d813a56.png
[df098c1f86ed480381b63415818d0e7e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/26350e0d68c845de83a7c5277b708c00.png
[227f16489b3a4a83a3512b6ebaa7f07c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/60152fc29744498fbef919c91d3479ec.png
[293e7993a313489d8c9cc395682794be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/8969326f112c47758420f084742eaa77.png
[13547856459144a590149eb63e6b77cd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/69b90dba69ca4a82a5892eca787a30dc.png
[d4c72058d01845299a9f68767f4260b6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/88c9e167deae495cb09cb08bf4ec0ccc.png
[84925d77a46443fc91ba3cb84c0b5c56.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/02/00294c4ec54d4d77bd096a5829862558.png