Java集合框架（二）Set

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

Set 实现类之一：HashSet

HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。

HashSet 具有以下特点：

不能保证元素的排列顺序
HashSet 不是线程安全的
集合元素可以是 null
1
2
3

HashSet的无序性：
注：无序性，不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序条件，而是根据数据的hashCode来决定。
如下面的HashSet对象，每次遍历，输出的顺序都是固定的，该顺序和add元素的顺序不同，是由集合元素的hashCode来决定。

Set set = new HashSet();
set.add(123);
set.add(445);
set.add("A");
set.add("B");
set.add("100");

set.forEach(System.out::println);
//输出：
A
100
B
123
445
1
2
3
4
5
6
7
8
9
10
11
12
13
14

解释：ArrayList的有序性和HashSet的无序性，它们的有序和无序，指的是集合元素是否按照数组索引的顺序（add顺序）进行添加。


HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。

**注：**若HashSet中的两个对象只重写了equals方法，没有重写hashCode方法，则认为这两个对象并不相等，可以存储多次。

对于存放在Set容器中的对象， 对应的类一定要重写equals() 和hashCode(Object obj) 方法，以实现对象相等规则 。即： “相等的对象必须具有相等的散列码” 。
 
向HashSet中添加元素的过程：

• 当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值，通过某种散列函数决定该对象在 HashSet 底层数组中的存储位置。（这个散列函数会与底层数组的长度相计算得到在数组中的下标，并且这种散列函数计算还尽可能保证能均匀存储元素，越是散列分布，该散列函数设计的越好）

• 如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，添加失败；如果为false，那么会保存该元素，但是该数组的位置已经有元素了，那么会通过链表的方式继续链接（即以链表的方式保存数据）。

HashSet底层：数组 + 链表格式。

“七上八下”：
jdk 7：新增元素放到数组中，指向原来的元素（原来的元素放到链表中）。
jdk 8：原来的元素放到数组中，指向新增元素（新增的元素放到链表中）。

注：如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。

底层也是数组，初始容量为16，当如果使用率超过0.75，（16*0.75=12）就会扩大容量为原来的2倍。（16扩容为32，依次为64,128…等）

 

重写 hashCode() 方法的基本原则

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

重写 equals() 方法的基本原则
以自定义的Customer类为例，何时需要重写equals()？

当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。

因此，违反了“相等的对象必须具有相等的散列码”。

结论：复写equals方法的时候一般都需要同时复写hashCode方法。通常参与计算hashCode 的对象的属性也应该参与到equals()中进行计算。
 

为什么HashSet需要引入HashCode呢？
答：若只通过equals方法来判断集合元素是否相等，那么每当我们向集合中新增一个元素时，都需要将这个元素与之前添加的所有元素进行比较，当全部不相等时才可以添加到集合。 而引入HashCode后，若元素的HashCode值不同，他们会被添加到集合中的不同位置，只有当HashCode值相同时，新增元素才需要与该HashCode位置上面的元素值进行比较，很大的提高的新增元素的效率。

 
Eclipse/IDEA 工具里hashCode()的重写
问题：为什么用Eclipse/IDEA复写hashCode方法，有31这个数字？

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

---

Set 实现类之二：LinkedHashSet

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

    简单来说，LinkedHashSet即为HashSet + 双向链表的组合，其双向链表的作用是用来保持元素插入的顺序，prev和next分别用来指向前一个和后一个元素，而第一个元素的prev为null。当遍历时，可以快速的以元素插入的顺序进行查找。

HashSet与LinkedHashSet区别：

LinkedHashSet遍历时可以按照元素添加的顺序进行输出。
1

---

Set 实现类之三：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和后面要讲的TreeMap采用红黑树的存储结构。
• 特点：有序，查询速度比List快。
  
  排序 - 自然排序
• 自然排序：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。否则，让人难以理解。

示例：
1.将不同类型的对象放到TreeSet中时会报错

Set set = new TreeSet();
set.add(10);
set.add(12);
set.add("hello");
set.add(20);

set.forEach(System.out::println);

报错：java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
原因：由于String类型和Integer类型无法比较大小，所以会报错。
1
2
3
4
5
6
7
8
9
10

2.若只为集合中元素的某个属性添加了CompareTo方法，则两个元素的该属性相同，TreeSet即会认为这两个元素相同，只会存入添加的第一个元素。

Set set = new TreeSet();
set.add(new User(15, "Tom"));
set.add(new User(18, "Jerry"));
set.add(new User(32, "Andi"));
set.add(new User(15, "Mary"));
set.add(new User(33, "Tony"));

set.forEach(System.out::println);

//User类继承了Comparable类，实现的CompareTo方法如下：只对age属性进行比较
@Override
public int compareTo(Object o) {
    if(o instanceof User){
        User user = (User) o;
        return this.age.compareTo(user.getAge());
    }else {
        throw new RuntimeException("对象类型不匹配...");
    }
}

//输出：
User{age=15, name='Tom'}
User{age=18, name='Jerry'}
User{age=32, name='Andi'}
User{age=33, name='Tony'}

解释：
可以看到age为15的对象只输出了一个，原因是TreeSet根据CompareTo方法来判断对象是否相等，
而Tom和Mary的age属性相同，所以TreeSet即认为这两个对象相等，只会存入第一个对象（即Tom）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

    
排序 - 定制排序
● 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。

示例：

Comparator comparator = new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        if (o1 instanceof User && o2 instanceof User) {
            User user1 = (User) o1;
            User user2 = (User) o2;

            if (!user1.getAge().equals(user2.getAge())) {
                return user1.getAge().compareTo(user2.getAge());
            } else {
                return user1.getName().compareTo(user2.getName());
            }
        } else {
            throw new RuntimeException("类型不匹配....");
        }
    }
};

Set set = new TreeSet(comparator);
set.add(new User(15, "Tom"));
set.add(new User(18, "Jerry"));
set.add(new User(32, "Andi"));
set.add(new User(15, "Mary"));
set.add(new User(33, "Tony"));

set.forEach(System.out::println);

//输出
User{age=15, name='Mary'}
User{age=15, name='Tom'}
User{age=18, name='Jerry'}
User{age=32, name='Andi'}
User{age=33, name='Tony'}

解释：
通过定制排序Comparator，我们分别去比较User对象的age属性和name属性，
这样即使age属性相同，若name属性不同也会被认为是两个不同的对象。
可以看到输出结果中同时出现了两个age为15的对象，且name属性按照字母进行了排序。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38