Java基础：集合：Set接口的介绍与使用

Love The Way You Lie 2023-10-05 18:52 17阅读 0赞

> **我是 ABin-阿斌：写一生代码，创一世佳话。 如果小伙伴们觉得我的文章有点 feel ，那就点个赞再走哦。**  
> ![在这里插入图片描述][01244a35a05f9070bf77418374331efc.png_pic_center]

## 一、概述： ##

*  **Set** 接口是 **Collection** 的子接口，**set** 接口没有提供额外的方法
 *  **Set** 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 **Set** 集合中，则添加操作失败。
 *  **Set** 判断两个对象是否相同不是使用 **==** 运算符，而是根据 **equals()** 方法进行判断
 *  **Set** 存储是无序的、不可存储重复的数据。

### 二、注意细节： ###

**以 HashSet 为例说明：**

*  **无序性：** 不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。  
    ![在这里插入图片描述][bb17f7dfd0e75e2b054c0f5c7b8b9204.png_pic_center]
 *  **不可重复性：** 保证添加的元素按照 **equals()** 判断时，不能返回 **true** 即：相同的元素只能添加一个。

### 三、实现类（HashSet）的具体介绍： ###

*  **HashSet** 是 **Set** 接口的典型实现，大多数时候使用 **Set** 集合时都使用这个实现类。
 *  **HashSet** 按 **Hash** 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。
 *  **HashSet 具有以下特点：**
    
     *  不能保证元素的排列顺序
     *  **HashSet** 不是线程安全的
     *  集合元素可以是 **null**
 *  HashSet 集合判断两个元素相等的标准：两个对象通过 **hashCode()** 方法比较相等，并且两个对象的 **equals()** 方法返回值也相等。
 *  对于存放在 **Set** 容器中的对象，对应的类一定要重写 **equals()** 和 **hashCode(Object obj)** 方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。

**向 HashSet 中添加元素的过程：**

*  当我们向 **HashSet** 中添加一个元素 **a** 时，首先调用元素 **a** 所在类的 **hashCode()** 方法，计算元素 **a** 的哈希值。此哈希值接着通过某种算法计算出在 **HashSet** 底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素：如果此位置上没有其他元素，则元素 **a** 添加成功。（情况1）
 *  如果此位置上有其他元素 b(或以链表形式存在的多个元素），则比较元素 **a** 与元素 **b** 的 **hash** 值：如果 **hash** 值不相同，则元素 **a** 添加成功。（情况2）
 *  如果hash值相同，进而需要调用元素 **a** 所在类的 **equals()** 方法：  
    **equals()** 返回 **true**，元素 **a** 添加失败  
    **equals()** 返回 **false**，则元素 **a** 添加成功。（情况3）
 *  对于添加成功的 情况2 和 情况3 而言：元素 **a** 与已经存在指定索引位置上数据以链表的方式存储。

**JDK7 与 JDK8 的不同之处：**

*   JDK7 ：元素 **a** 放到数组中，指向原来的元素。
 *   JDK8 ：原来的元素在数组中，指向元素 **a**  
    ![在这里插入图片描述][53b8916dee492685645035cfc7d71383.png_pic_center]  
    **记忆口诀总结：** 七上八下

**HashSet底层：** 数组+链表的结构（JDK7版本）

![在这里插入图片描述][f55f5f4a382eb34bbaf7b36d2d707b47.png_pic_center]

### 四、重写 hashCode() 方法与 equals() 方法的基本原则： ###

**重写 hashCode() 方法：**

*  在程序运行时，同一个对象多次调用 **hashCode()** 方法应该返回相同的值。
 *  当两个对象的 **equals()** 方法比较返回 **true** 时，这两个对象的 **hashCode()** 方法的返回值也应相等。
 *  对象中用作 **equals()** 方法比较的 **Field**，都应该用来计算 **hashCode** 值。

**重写 equals() 方法：**

**以自定义的 Customer 类为例，何时需要重写 equals()？**

*  当一个类有自己特有的“逻辑相等”概念,当改写 **equals()** 的时候，总是要改写 **hashCode()**，根据一个类的 **equals** 方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据 **Object.hashCode()** 方法，它们仅仅是两个对象。
 *  因此，违反了“相等的对象必须具有相等的散列码”。
 *  **结论：** 复写 **equals** 方法的时候一般都需要同时复写 **hashCode** 方法。通常参与计算**hashCode** 的对象的属性也应该参与到 **equals()** 中进行计算。

**Eclipse、IDEA工具里 hashCode() 的重写：**

*  以 **Eclipse**、**IDEA**为例，在自定义类中可以调用工具自动重写 **equals** 和 **hashCode**。

**问题：** 为什么用 **Eclipse**、**IDEA** 复写 **hashCode** 方法，有 **31** 这个数字？

![在这里插入图片描述][4de87f4703b827d1140f2dabe5efb978.png_pic_center]  
**答：**

*  选择系数的时候要选择尽量大的系数。因为如果计算出来的 **hash** 地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）
 *  并且 **31** 只占用 **5bits**,相乘造成数据溢出的概率较小。
 *  **31** 可以 由 **i \* 31== (i<<5) - 1** 来表示,现在很多虚拟机里面都有做相关优化。（提高算法效率）
 *  **31** 是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终出来的结果只能被素数本身和被乘数还有 **1** 来整除！(减少冲突)

### 五、实现类（LinkedHashSet）的具体介绍： ###

*  **LinkedHashSet** 是 **HashSet** 的子类
 *  **LinkedHashSet** 根据元素的 **hashCode** 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
 *  **LinkedHashSet** 插入性能略低于 **HashSet**，但在迭代访问 **Set** 里的全部元素时有很好的性能。
 *  **LinkedHashSet** 不允许集合元素重复。

##### LinkedHashSet 底层结构： #####

*  **LinkedHashSet** 作为 **HashSet** 的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。
 *  **优点：** 对于频繁的遍历操作，**LinkedHashSet** 效率高于 **HashSet**
 *  **图中下方双向链表指向**  
    ![在这里插入图片描述][6df31e647fca6fca84968924288b4d0f.png_pic_center]

### 六、实现类（TreeSet）的具体介绍： ###

*  **TreeSet** 是 **SortedSet** 接口的实现类，**TreeSet** 可以确保集合元素处于排序状态。
 *  **TreeSet** 底层使用 **红黑树** 结构存储数据
 *  **新增的方法如下：**
    
     *  **Comparator comparator()**
     *  **Object first()**
     *  **Object last()**
     *  **Object lower(Object e)**
     *  **Object higher(Object e)**
     *  **SortedSet subSet(fromElement, toElement)**
     *  **SortedSet headSet(toElement)**
     *  **SortedSet tailSet(fromElement)**
 *  **TreeSet 两种排序方法：** 自然排序 和 定制排序。默认情况下，**TreeSet** 采用自然排序。

#### 自然排序与定制排序： ####

##### 自然排序： #####

*  **TreeSet** 会调用集合元素的 **compareTo(Object obj)** 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列
 *  如果试图把一个对象添加到 **TreeSet** 时，则该对象的类必须实现 **Comparable** 接口。
    
     *  实现 **Comparable** 的类必须实现 **compareTo(Object obj)** 方法，两个对象即通过 **compareTo(Object obj)** 方法的返回值来比较大小。
 *  **Comparable 的典型实现：**
    
     *  **BigDecimal**、**BigInteger** 以及所有的数值型对应的包装类：按它们对应的数值大小进行比较
     *  **Character：** 按字符的 **unicode** 值来进行比较
     *  **Boolean：** **true** 对应的包装类实例大于 **false** 对应的包装类实例
     *  **String：** 按字符串中字符的 **unicode** 值进行比较
     *  **Date、Time：** 后边的时间、日期比前面的时间、日期大
 *  向 **TreeSet** 中添加元素时，只有第一个元素无须比较 **compareTo()** 方法，后面添加的所有元素都会调用 **compareTo()** 方法进行比较。
 *  因为只有相同类的两个实例才会比较大小，所以向 **TreeSet** 中添加的应该是同一个类的对象。  
    对于 **TreeSet** 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 **compareTo(Object obj)** 方法比较返回值。
 *  当需要把一个对象放入 **TreeSet** 中，重写该对象对应的 **equals()** 方法时，应保证该方法与 **compareTo(Object obj)** 方法有一致的结果：如果两个对象通过 **equals()** 方法比较返回 **true**，则通过 **compareTo(Object obj)** 方法比较应返回 **0**。否则，让人难以理解。

##### 定制排序： #####

*  **TreeSet** 的自然排序要求元素所属的类实现 **Comparable** 接口，如果元素所属的类没有实现**Comparable** 接口，或不希望按照升序(默认情况)的方式排列元素或希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过 **Comparator** 接口来实现。需要重写 **compare(T o1,T o2)** 方法。
 *  利用 **int compare(T o1,T o2)** 方法，比较 **o1** 和 **o2** 的大小：如果方法返回正整数，则表示 **o1** 大于 **o2**；如果返回 **0**，表示相等；返回负整数，表示 **o1** 小于 **o2**。
 *  要实现定制排序，需要将实现 **Comparator** 接口的实例作为形参传递给 **TreeSet** 的构造器。
 *  此时，仍然只能向 **TreeSet** 中添加类型相同的对象。否则发生 **ClassCastException** 异常。
 *  使用定制排序判断两个元素相等的标准是：通过 **Comparator** 比较两个元素返回了 **0**。

**总结概括：**

1.  向 **TreeSet** 中添加的数据，要求是相同类的对象。
2.  **两种排序方式：** 自然排序（实现 **Comparable** 接口） 和 定制排序（**Comparator**）
3.  自然排序中，比较两个对象是否相同的标准为：**compareTo()** 返回 **0** 不再是 **equals()**
4.  定制排序中，比较两个对象是否相同的标准为：**compare()** 返回 **0** 不再是 **equals()**

**案例展示：**

public class User implements Comparable{
        
        private String name;
        private int age;
        
        //略：无参构造、有参构造、get\set\toString
    
        @Override
        public boolean equals(Object o) {
        
            System.out.println("User equals()....");
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
    
            User user = (User) o;
    
            if (age != user.age) return false;
            return name != null ? name.equals(user.name) : user.name == null;
        }
    
        @Override
        public int hashCode() {
         //return name.hashCode() + age;
            int result = name != null ? name.hashCode() : 0;
            result = 31 * result + age;
            return result;
        }
    
        //按照姓名从大到小排列,年龄从小到大排列
        @Override
        public int compareTo(Object o) {
        
            if(o instanceof User){
        
                User user = (User)o;
                //从大到小
               //return -this.name.compareTo(user.name);
                int compare = -this.name.compareTo(user.name);
                if(compare != 0){
        
                    return compare;
                }else{
        
                    return Integer.compare(this.age,user.age);
                }
            }else{
        
                throw new RuntimeException("输入的类型不匹配");
            }
    
        }
    }

public class TreeSetTest {
        
        @Test
        public void test1(){
        
            TreeSet set = new TreeSet();
    
            //失败：不能添加不同类的对象
    //        set.add(2020);
    //        set.add(2021);
    //        set.add("牛年大吉哦");
    //        set.add(new User("牛牛",2));
    
                //举例一：
    //        set.add(34);
    //        set.add(-34);
    //        set.add(43);
    //        set.add(11);
    //        set.add(8);
    
            //举例二：
            set.add(new User("Tom",12));
            set.add(new User("Jerry",32));
            set.add(new User("Jim",2));
            set.add(new User("Mike",65));
            set.add(new User("Jack",33));
            set.add(new User("Jack",56));
    
    
            Iterator iterator = set.iterator();
            while(iterator.hasNext()){
        
                System.out.println(iterator.next());
            }
    
        }
    
        @Test
        public void test2(){
        
            Comparator com = new Comparator() {
        
                //按照年龄从小到大排列
                @Override
                public int compare(Object o1, Object o2) {
        
                    if(o1 instanceof User && o2 instanceof User){
        
                        User u1 = (User)o1;
                        User u2 = (User)o2;
                        return Integer.compare(u1.getAge(),u2.getAge());
                    }else{
        
                        throw new RuntimeException("输入的数据类型不匹配");
                    }
                }
            };
    
            TreeSet set = new TreeSet(com);
            set.add(new User("Tom",12));
            set.add(new User("Jerry",32));
            set.add(new User("Jim",2));
            set.add(new User("Mike",65));
            set.add(new User("Mary",33));
            set.add(new User("Jack",33));
            set.add(new User("Jack",56));
    
    
            Iterator iterator = set.iterator();
            while(iterator.hasNext()){
        
                System.out.println(iterator.next());
            }
        }
    }

[01244a35a05f9070bf77418374331efc.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/01244a35a05f9070bf77418374331efc.png#pic_center
[bb17f7dfd0e75e2b054c0f5c7b8b9204.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/bb17f7dfd0e75e2b054c0f5c7b8b9204.png#pic_center
[53b8916dee492685645035cfc7d71383.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/53b8916dee492685645035cfc7d71383.png#pic_center
[f55f5f4a382eb34bbaf7b36d2d707b47.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/f55f5f4a382eb34bbaf7b36d2d707b47.png#pic_center
[4de87f4703b827d1140f2dabe5efb978.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/4de87f4703b827d1140f2dabe5efb978.png#pic_center
[6df31e647fca6fca84968924288b4d0f.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/6df31e647fca6fca84968924288b4d0f.png#pic_center