------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
一、Set集合
Set集合不允许包含相同的元素，如果试图把两个相同的元素加入同一个Set集合中，则添加
操作失败，add方法返回false，而新元素不会被加入。
Set判断两对象相同不是使用==运算符，而是根据equals方法。也就是说，只要两个对象用
equals方法比较返回true，Ser就不会接受这两个对象；反之，只要两个对象用equals方法比较
返回false，SEt就会接受这两个对象（甚至这两个对象是同一个对象，Set也可把它们当成两个对
象出来）。下面是使用普通Set的示例程序。
1 import java.util.HashSet;
2 import java.util.Set;
3
4
5 public class SetTest {
6
7 public static void main(String[] args) {
8 Set names = new HashSet<>();
9 //添加一个字符串对象
10 names.add(new String("暨雪"));
11 //再次添加一个字符串对象
12 //因为两个字符串对象通过equals方法比较相等
13 //所以添加失败，返回false
14 boolean reasult = names.add(new String("暨雪"));
15 //从下面输出看到集合只有一个元素
16 System.out.println(reasult + "-->" + names);
17 }
18
19 }
运行结果：
false-->[暨雪]
从上面程序中可以看出，names集合两次添加的字符串对象明显不是同一对象（因为两次都调
用了new关键字来创建字符串对象），这两个字符串对象使用==运算符判断肯定返回false，但通过
equals方法比较将返回true，所以添加失败。最后结果输出只有一个元素。
1.HashSet类
HashSet是Set接口的典型实现，大多数时候使用Set集合是就是使用这个实现类。HashSet按Hash
算法来存储集合中的元素，因此具有很好的存取和查找性能。
HashSet具有以下特点：
1）不能保证元素的排序顺序，顺序有可能发生变化。
2）HashSet不是同步的，如果多线程同时访问一个HashSet，假设有两个或两个以上线程同时
修改了HashSet集合时，则必须通过代码来保证其同步。
3）集合元素值可以是null。
HashSet集合判断两个以上相等的标准是两个对象通过equals()方法比较相等，并且两个对象的
hashCode()方法返回值也相等。
下面程序分别提供了三个类A、B和C，它们分别重写了equals()、hashCode()两个方法的一个或全部
，通过此程序可以看到HashSet判断集合元素相同的标准。
1 import java.util.HashSet;
2
3
4 public class HashSetTest {
5 //类A的equals方法总是返回true，但没有重写hashCode方法
6 static class A {
7 @Override
8 public boolean equals(Object o) {
9 return true;
10 }
11 }
12 //类B的hashCode总是返回1，但没有重写equals方法
13 static class B {
14 @Override
15 public int hashCode() {
16 return 1;
17 }
18 }
19 //类C重写了hashCode方法和equals方法
20 static class C {
21 @Override
22 public int hashCode() {
23 return 2;
24 }
25 @Override
26 public boolean equals(Object obj) {
27 return true;
28 }
29 }
30
31 public static void main(String[] args) {
32
33 HashSet names = new HashSet<>();
34 names.add(new A());
35 names.add(new A());
36 names.add(new B());
37 names.add(new B());
38 names.add(new C());
39 names.add(new C());
40
41 System.out.println(names);
42 }
43
44 }
运行结果：
[[email protected], [email protected], [email protected], [email protected], [email protected]]
从上面程序可以看出，即使两个A对象通过equals()方法比较返回true，但HashSet依然把它们当成
两个对象；即使两个B对象的hashCode()返回相同值（都是1），但HashSet依然把它们当成同一个
对象。
注意：
当把一个对象放入HashSet中时，如果需要重写该方法对应类的equals()方法，则也应该重写
hashCode()方法。其规则是：如果两个对象通过equals()方法比较返回true，这两个对象的hashCode
()值也应该相同。
重写hashCode()方法的基本规则：
1）在程序运行中，同一对象多次调用hashCode()方法应该返回相同的值。
2）当两个对象通过equals()方法比较返回true时，这两个对象的hashCode()方法应返回相等的值。
3）对象中用作equals()方法比较标准的Filed，都应该用计算hashCode值。
hashCode返回值的计算：
return f1.hashCode() + (int) f2;
为了避免直接相加产生偶然相等（两个对象f1、f2Field并不相等，但他们的和恰好相等），
可以通过为个Field乘以任意一个质数后在相加。
return f1.hashCode() * 17 + (int) f2 * 13;
如果向HashSet中添加一个可变对象后，后面出现修改了该可变对象的Field，则可能导致
它与集合中的其他元素相同（即两个对象通过equals()方法比较返回true，两个对象的
hashCode()值也相等）。这就有可能导致HashSet中包含两个相同的对象。下面程序演示了这
种情况。
1 import java.util.HashSet;
2 import java.util.Iterator;
3
4 class R {
5 int count;
6 public R (int count){
7 this.count = count;
8 }
9 @Override
10 public String toString() {
11
12 return "R[count:" + count + "]";
13 }
14 @Override
15 public boolean equals(Object obj) {
16
17 if (this == obj) {
18 return true;
19 }
20 if (obj != null && obj.getClass() == R.class) {
21 R r = (R) obj;
22 if (r.count == this.count) {
23 return true;
24 }
25 }
26 return false;
27 }
28 @Override
29 public int hashCode() {
30
31 return this.count;
32 }
33 }
34 public class HashSetTest2 {
35
36 public static void main(String[] args) {
37
38 HashSet hs = new HashSet<>();
39 hs.add(new R(5));
40 hs.add(new R(-3));
41 hs.add(new R(9));
42 hs.add(new R(-2));
43 //打印HashSet集合，集合没有重复
44 System.out.println(hs);
45 //取出第一个元素
46 Iterator it = hs.iterator();
47 R first = (R) it.next();
48 //为第一个元素的count实例变量赋值
49 first.count = -3;
50 //再次输出HashSet集合，集合元素有重复元素
51 System.out.println(hs);
52 //删除count为-3的R对象
53 hs.remove(new R(-3));
54 System.out.println(hs);
55 System.out.println("hs是否包count为-3的R对象？" + hs.contains(new R(-3)));
56 System.out.println("hs是否包count为5的R对象？" + hs.contains(new R(5)));
57 System.out.println("hs是否包count为9的R对象？" + hs.contains(new R(9)));
58 }
59
60 }
运行结果：
[R[count:5], R[count:9], R[count:-3], R[count:-2]] [R[count:-3], R[count:9], R[count:-3], R[count:-2]] [R[count:-3], R[count:9], R[count:-2]] hs是否包count为-3的R对象？false hs是否包count为5的R对象？false hs是否包count为9的R对象？true
上面程序中的first.count = -3;因为改变了HashSet集合中第一个R对象的count实例变量
的值，这将导致该R对象与集合中的其他对象相同。当试图删除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不可能准确访问该元素。