Java集合详解2——Set

深藏阁楼爱情的钟 2022-12-20 02:07 163阅读 0赞

### Java集合详解2——Set ###

*   *  List、Set与Map
     *   *  hashSet
         *  LinkedHashSet
         *  TreeSet类
         *  EnumSet类
         *  小结：

## List、Set与Map ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center]

**概述：**

*  Set集合类似于一个罐子，程序可以依次把多个对象“丢进”Set集合，而Set集合通常不能记住元素的添加顺序。实际上Set就是Collection只是行为略有不同(Set不允许包含重复元素)。
 *  Set集合不允许包含相同的元素，如果试图把两个相同元素加入同一个Set集合中，则添加操作失败，add()方法返回false，且新元素不会被加入。

### hashSet ###

*  **HashSet**  
    底层数据结构是哈希表（HashMap）。(无序,唯一)  
    不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也可能发生变化；  
    HashSet不是同步的；  
    集合元素值可以是null；  
    线程不安全，效率高

public HashSet() { 
            map = new HashMap<>();
        }
        //添加
        public boolean add(E e) { 
            return map.put(e, PRESENT)==null;
        }
        //移除
        public boolean remove(Object o) { 
            return map.remove(o)==PRESENT;
        }

如何来保证元素唯一性?  
1.依赖两个方法：hashCode()和equals()

//没有重写hashCode()和equals()
    //实体类
    class 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 +'}';
        }
    }
    //测试类
    public class SetTest { 
        public static void main(String[] args) { 
            Set<Student> hashSet = new HashSet<>();
            Student s1 = new Student("哪吒", 23);
            Student s2 = new Student("三太子", 24);
            Student s3 = new Student("小足熊", 23);
            Student s4 = new Student("小龙女", 25);
            Student s5 = new Student("哪吒", 23);
            hashSet.add(s1);
            hashSet.add(s2);
            hashSet.add(s3);
            hashSet.add(s4);
            hashSet.add(s5);
            for (Student student : hashSet) { 
               System.out.println(student.getName()+"=="+student.getAge());
            }
        }
    }

输出：并不能保证元素的唯一性  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 1]  
解决：重写equals/hashCode

//判断判断两个对象是否相等，对象是否存在，对象的name和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);
        }

重写后：可以看到重复的元素已经被覆盖，保证了集合中元素的唯一性。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 2]

### LinkedHashSet ###

*  底层数据结构是链表和哈希表。(FIFO插入有序,唯一)  
    1.由链表保证元素有序  
    2.由哈希表保证元素唯一

public LinkedHashSet() { 
            super(16, .75f, true);
        }
        //super即hashSet
        HashSet(int initialCapacity, float loadFactor, boolean dummy) { 
            map = new LinkedHashMap<>(initialCapacity, loadFactor);
        }

### TreeSet类 ###

TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。

**内部存储机制**  
TreeSet内部实现的是红黑树，默认整形排序为从小到大。(唯一，有序)

public TreeSet() { 
            this(new TreeMap<E,Object>());
        }

*  与HashSet集合相比，TreeSet还提供了几个额外方法：  
    `Comparator comparator()`:如果TreeSet采用了定制顺序，则该方法返回定制排序所使用的Comparator，如果TreeSet采用自然排序，则返回null；  
    `Object first()`:返回集合中的第一个元素；  
    `Object last()`:返回集合中的最后一个元素；  
    `Object lower(Object e)`：返回指定元素之前的元素。  
    `Object higher(Object e)`：返回指定元素之后的元素。  
    `SortedSet subSet（Object fromElement，Object toElement）`：返回此Set的子集合，含头不含尾；  
    `SortedSet headSet(Object toElement)`：返回此Set的子集，由小于toElement的元素组成；  
    `SortedSet tailSet(Object fromElement)`：返回此Set的子集，由大于fromElement的元素组成;

public class SetTest { 
        public static void main(String[] args) { 
            TreeSet<Integer> treeSet = new TreeSet<>();
            treeSet.add(23);
            treeSet.add(12);
            treeSet.add(123);
            treeSet.add(1);
            for (Integer i:treeSet){ 
                System.out.println(i);
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 3]

**自然排序：**  
TreeSet会调用集合元素的compareTo(Objec obj)方法来比较元素之间的大小关系，然后将集合元素按升序排列，这就是自然排序。  
如果使用实体类需要重写compareTo方法

class Student implements Comparable<Student>{ 
    		......
    	@Override
        public int compareTo(Student o) { 
            //比较age
            int num=this.age-o.age;
            //如果age相等则比较name长度
            int num1=num==0?this.name.length()-o.name.length():num;
            //如果前两者都相等则比较name字符串
            int num2=num1==0?this.name.compareTo(o.name):num1;
            return num2;
        }
    }

**注意问题**

*  大部分类在实现CompareTo(Object o)方法时，都需要将被比较对象obj强制类型转换成相同类型，因为只有相同的两个实例才会比较大小。
 *  加入集合的类都必须实现Comparable接口，否则会引发ClassCastException异常。
 *  向TreeSet集合中添加元素时，只有第一个元素无须实现Comparable接口，后面添加的所有元素都必须实现Comparable接口。当然这也不是一种好做法，当试图从TreeSet中取出元素时，依然会引发ClassCastException异常。
 *  不要修改已经存入集合的实例变量，这将导致它与其他对象的大小顺序发生改变，但TreeSet集合不会再次调整它们的顺序，这点和HashSet一样。

对于TreeSet集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj)方法比较是否返回0，如果是0则认为对象相等，否则认为不相等。

**定制排序**  
TreeSet的自然排序是根据集合元素的大小，TreeSet将它们以升序排列。如果需要实现定制排序，例如降序排序，则可通过Comparator接口的帮助。该接口里包含一个int compare(T o1,T o2)方法，用于比较o1和o2的大小。由于Comparator是一个函数式接口，因此还可以使用Lambda表达式来代替Comparator子类对象。

public class SetTest { 
        public static void main(String[] args) { 
            TreeSet<Integer> treeSet = new TreeSet<>(new Comparator<Integer>() { 
                @Override
                public int compare(Integer o1, Integer o2) { 
                    return o2-o1;
                }
            });
            //TreeSet<Integer> treeSet = new TreeSet<>((a,b)->{return b-a;});//使用lambda表达式
            treeSet.add(23);
            treeSet.add(12);
            treeSet.add(123);
            treeSet.add(1);
            for (Integer i:treeSet){ 
                System.out.println(i);
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 4]

### EnumSet类 ###

*  EnumSet是一个专门为枚举类设计的集合类，EnumSet中的所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式或隐式地指定。EnumSet的集合元素也是有序的，EnumSet以枚举值在Enum类内的定义顺序来决定集合元素的顺序。
 *  EnumSet在内部以位向量的形式存储，这种存储形式非常紧凑、高效，因此EnumSet对象占用内存很小，而且运行效率很好。
 *  EnumSet集合不允许加入null元素。

EnumSet类没有暴露任何构造器来创建该类的实例，EnumSet类提供了以下类方法来创建EnumSet对象。

`EnumSet allOf(Class elementType)`：创建一个包含指定枚举类里所有枚举值的EnumSet集合。  
`EnumSet complementOf(EnumSet s)`：创建一个其元素类型与指定EnumSet里元素类型相同的EnumSet集合，新的集合里包含原集合不包含的枚举值。  
`EnumSet copyOf(Collection c)`：使用一个普通集合来创建EnumSet集合；  
`EnumSet copyOf(EnumSet s)`:复制原集合；  
`EnumSet noneOf(Class elementType)`:创建一个元素类型为指定枚举类型的空EnumSet；  
`EnumSet of(E first，E...rest)`:创建一个包含一个或多个枚举值的EnumSet集合。传入的枚举值必须是同一枚举类。  
`EnumSet range(E from,E to)`:创建一个包含从from到to枚举值范围所有枚举值的EnumSet集合。

### 小结： ###

**Set具有与Collection完全一样的接口，因此没有任何额外的功能，不像前面有两个不同的List。实际上Set就是Collection,只是行为不同。(这是继承与多态思想的典型应用：表现不同的行为。)Set不保存重复的元素。  
Set 存入Set的每个元素都必须是唯一的，因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。**

上一篇：[Java集合详解1——List][Java_1_List]  
下一篇：[Java集合详解3——List与Set小结][Java_3_List_Set]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/0e9d398b24d24cdfa55c654389182d22.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201109165239985.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201109165803289.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201109210101141.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201110085356483.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTEwNTUx,size_16,color_FFFFFF,t_70#pic_center
[Java_1_List]: https://blog.csdn.net/qq_41510551/article/details/109561893
[Java_3_List_Set]: https://blog.csdn.net/qq_41510551/article/details/109591757