Set集合

前面已经介绍了Set集合类似于一个罐子，一旦对象丢进Set集合，集合里多个对象之间没有明显的顺序。Set集合与Collection
基本完全一样，没有提供任何额外的方法。
Set集合不允许包含相同的元素，如果试图把两个相同元素加入到同一个Set集合中，则添加失败，add方法返回false，且
新元素不会被加入。
Set判断两个对象相同不是使用==运算符，而是根据equals方法。也就是说，如果只要两个对象用equals方法比较返回
true，Set就不会接受这两个对象；反之，只要两个对象用equals方法比较返回false，Set就会接受这两个对象（甚至这

两个对象是同一个对象，Set也可把它们当成两个对象处理）。下面是使用Set的程序实例。

[java]  view plain copy

1. public class TestSet {  
2.   
3.     public static void main(String[] args) {  
4.         Set books = new HashSet();  
5.         books.add(new String("张大三"));  
6.         System.out.println(books);//打印结果：[张大三]  
7.         //再次添加一个字符串对象  
8.         //因为这连个字符串对象通过equals方法比较相等，所以添加失败，返回false  
9.         boolean result = books.add(new String("张大三"));  
10.         //下面看到集合中只有一个元素  
11.         System.out.println(result);  
12.         System.out.println(books);//打印结果：[张大三]  
13.     }  
14. }  

从上面程序中可以看出，books集合两次添加的字符串对象明显不是同一个对象（因为两个都调用了new关键字来创建对象）
，这两个字符串对象使用==运算符判断肯定返回false，但它们通过equals比较返回true，所以添加失败。最后输出books
集合时，将会看到输出结果只有一个元素。

上面介绍的Set集合的通用知识，因为完全适合HashSet、TreeSet、EnumSet三个实现类，只是三个实现类还各有特色。

HashSet类

HashSet是Set接口的典型实现，大多数时候使用Set集合时就是使用这个实现类。HashSet按Hash算法来存储集合中的元素
，因此具有很好的存取和查找功能。
HashSet具有以下的特点：
== 不能保证元素的排列顺序，顺序有可能发生变化
== HashSet不是同步的，如果多个线程同时访问一个Set集合，如果多个线程同时访问一个HashSet，如果有2条或者
2条以上线程同时修改了HashSet集合时，必须通过代码来保证其同步
== 集合元素可以是null

当像HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据
该hashCode值来决定该对象在HashSet中存储位置。如果两个元素通过equals比较返回true，但它们的hashCode()方法返回值
不相等，HashSet将会把它们存储在不同位置，也可以添加成功。
简单说，HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法
返回值也相等。 
下面程序分别提供了三个类A、B、C，他们分别重写了equals、hashCode两个方法的一个或全部，通过下面程序
可以看到HashSet判断集合元素相同的标准。

[java]  view plain copy

1. public class TestHashSet {  
2.   
3.     public static void main(String[] args) {  
4.          HashSet books = new HashSet();  
5.          books.add(new A());  
6.          books.add(new A());  
7.          books.add(new B());  
8.          books.add(new B());  
9.          books.add(new C());  
10.          books.add(new C());  
11.          System.out.println(books);//打印结果：[B@1, B@1, C@2, A@4f1d0d, A@1fc4bec]  
12.     }  
13.     //A类中的equals方法总是返回true，但没有重写其hashCode()方法  
14.     public class A{  
15.         public boolean equals(Object obj){  
16.             return true;  
17.         }  
18.     }  
19.     //类B的hashCode()方法总是返回1，但没有重写其equals()方法  
20.     class B{  
21.         public int hashCode(){  
22.             return 1;  
23.         }  
24.     }  
25.     //类c的hashCode()方法总是返回2，重写其equals()方法  
26.     class C{  
27.         public int hashCode(){  
28.             return 2;  
29.         }  
30.         public boolean equals(Object obg){  
31.             return true;  
32.         }  
33.     }  
34. }  

上面程序中books集合分别添加了2个A对象、2个B对象和2个C对象，其中C对象重写了equals()方法总是返回true、
hashCode()方法总是返回2，这将导致HashSet将会把2个C对象当成同一个对象。运行上面程序，看到如下结果：
[B@1, B@1, C@2, A@4f1d0d, A@1fc4bec] 
这里有一个问题需要注意：如果需要把一个对象放入HashSet中时，如果重写该对象对应类的equals方法时，也应该重写
其hashCode()方法，其规则是：如果2个对象通过equals方法比较返回true时，这两个对象的hashCode值也应该相同。
如果两个对象通过equals方法比较返回true时，但这两个对象的hashCode()方法返回不同的hashCode时，这将导致
HashSet将会把这两个对象保存在HashSet的不同的位置，从而两个对象都可以添加成功，这与Set集合的规则有点出入。
如果两个对象的hashCode()方法返回的hashCode相同，但它们通过equals方法比较返回false时将更麻烦：因为两个
对象的hashCode值相同，HashSet将试图把它们保存在同一个位置，但实际上又不行（否则将只剩下一个对象），所以处理
起来比较麻烦；而且HashSet访问集合元素时是根据元素的hashCode值来访问的，如果HashSet中包含两个元素有相同的hashCode
值，将会导致性能下降。
hashCode方法对于HashSet的作用是什么？
首先要理解hash算法的功能：它能保证通过一个对象快速查找到另一个对象。hash算法的价值在于速度，它可以保证
查询得到快速执行。当需要查询集合中某一个元素时，hash算法可以直接根据该元素的值得到该元素保存在何处，从而
可以让程序快速找到该元素。为了理解这个概念，我们先看数组（数组是所有能存储一组元素里最快的数据结构）：数组可以
包含多个元素，每个元素也有索引，如果需要访问某个数组元素，只需提供该元素的索引，该索引即指出了该元素在数组内存
区里的位置。
表面上看起来，HashSet集合里的元素都没有索引，实际上当程序向HashSet集合中添加元素时，HashSet会根据该元素 
的hashCode值来决定它的存储位置--也就是说，每个元素的hashCode值就是它的“索引”。
为什么不直接使用数组，还需要使用HashSet呢？因为数组元素的索引是连续的，而且数组的长度是固定的，无法自由
增加数组的长度。而HashSet就不一样了，HashSet采用每个元素的hashCode值作为其索引，从而可以自由增加数组的长度
，并可以根据元素的hashCode来访问元素。因此，当从HashSet中访问元素时，HashSet先计算该元素的hashCode值（也就是
该对象的hashCode()方法返回的值），最后直接到HashSe对应的位置去取出该元素。
HashSet中每个能存储元素的“槽位（slot）”通常称为“桶（bucket）”，如果有多个元素的hashCode相同，但它们通过
equals方法比较返回false，就需要在一个“桶”里放多个元素，从而导致性能下降。 
下面给出重写hashCode()方法的基本规则：
==当两个对象通过equals方法比较返回true时，这两个对象的hashCode应该相等。
==对象中用作equals比较标准的属性，都应该用来计算hashCode值。

如果想HashSet中添加一个可变对象后，并且后面程序修改了该可变对象的属性，可能导致它与集合中其他元素相同
（即两个对象通过equals方法比较返回true，两个对象的hashCode值也相等），这就有可能导致HashSet中包含两个相同的
对象。下面程序演示了这种情况。

[java]  view plain copy

1. public class R {  
2.   
3.     int count;  
4.       
5.     public R(int count){  
6.         this.count = count;  
7.     }  
8.     public String toString(){  
9.         return "R(count属性：" + count + ")";  
10.     }  
11.       
12.     public boolean equals(Object obj){  
13.         if(obj instanceof R){  
14.             R r = (R)obj;  
15.             if(r.count == this.count){  
16.                 return true;  
17.             }  
18.         }  
19.         return false;  
20.     }  
21.       
22.     public int hashCode(){  
23.         return this.count;  
24.     }  
25. }  

[java]  view plain copy

1. public class TestHashSet2 {  
2.   
3.     public static void main(String[] args) {  
4.         HashSet hs = new HashSet();  
5.         hs.add(new R(5));  
6.         hs.add(new R(-3));  
7.         hs.add(new R(9));  
8.         hs.add(new R(-2));  
9.         System.out.println(hs);  
10.         //打印出的结果是：[R(count属性：5), R(count属性：9), R(count属性：-3), R(count属性：-2)]  
11.         //集合元素没有重复  
12.           
13.         //取出第一个元素  
14.         Iterator it = hs.iterator();  
15.         R first = (R)it.next();  
16.         //为第一个元素的count属性赋值  
17.         first.count = -3;  
18.         System.out.println(hs);  
19.         //打印出的结果是：[R(count属性：-3), R(count属性：9), R(count属性：-3), R(count属性：-2)]  
20.         //集合元素有重复元素  
21.           
22.         //删除一个count为-3的R对象  
23.         hs.remove(new R(-3));  
24.         System.out.println(hs);  
25.         //打印出的结果是：[R(count属性：-3), R(count属性：9), R(count属性：-2)]  
26.         //可以看到集合元素少了一个  
27.           
28.         System.out.println("hs集合中是否包含count为-3的R对象？" + hs.contains(new R(-3)));  
29.         //输出false  
30.           
31.         System.out.println("hs集合中是否包含count为5的R对象？" + hs.contains(new R(5)));  
32.         //输出false  
33.     }  
34. }  

如上面的程序提供了R类，R类中重写了equals(Obejct obj)方法和hashCode()方法，这两个方法都是通过R对象的属性
来判断的 ，修改了Set集合中第一个R对象的count属性，这将导致该R对象与集合中其他对象相同。打印出来的数据可以看出
集合中第一个元素和第三个元素完全相同，这表明两个元素已经重复，但因为HashSet在添加他们的时候已经把它们添加到了
不同地方，所以HashSet完全可以容纳两个相同的元素。
但此时HashSet比较混乱：当试图删除count为-3的R对象时，HashSet会计算稿对象的hashCode值，从而找出该对象在
集合中的位置 ，然后把此处的对象与count为-3的R对象通过equals方法进行比较，如果想等则删除该对象---HashSet只有
第三个元素才满足该条件（第一个元素实际上保存在count为5的R对象的位置），所以第三个元素被删除。至于第一个count为
-3的R对象，它保存在count为5的R对象的位置，但使用equals方法拿它和count为5的R对象比较又返回false，这将导致
HashSet不可能准确访问该元素。
所以说，当向HashSet中添加可变对象时，必须十分小心。如果修改HashSet集合中的对象，有可能导致该对象与集合中
其他对象相等，从而导致HashSet无法准确访问该对象。
HashSet还有一个子类LinkedHashSet，LinkedHashSet集合也是根据元素hashCode值来决定元素存储位置，但它同时
使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。也就是说，当遍历LinkedHashSet集合里元素时，
HashSet将会元素的添加的顺序来访问集合里的元素。
LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时将有很好
的性能，因为他以链表来维护内部顺序。

[java]  view plain copy

1. public class TestLinkedHashSet {  
2.   
3.     public static void main(String[] args) {  
4.          LinkedHashSet books = new LinkedHashSet();  
5.          books.add("我爱Java");  
6.          books.add("我爱Android");  
7.          books.add("我爱学习");  
8.          System.out.println(books);  
9.          //[我爱Java, 我爱Android, 我爱学习]  
10.     }  
11. }  

上面的集合里，元素的顺序正好与添加顺序一致。