《疯狂Java讲义精粹》读书笔记13 Set集合（二）

================《疯狂Java讲义精粹》读书笔记13 ------  Set集合（二）==============

　　在上一篇笔记中提出了这样一个问题：修改Set中对象的成员变量之后可能与集合中的其他元素相等，这不就与Set集合的规则矛盾了吗？

先考虑HashSet的情况：

import java.util.HashSet;
import java.util.Iterator;

class R{
    int count;
    public R(int count){
        this.count = count;
    }
    
    //重写toString()方法
    public String toString(){
        return "R[count:" + count + "]";
    }
    
    //重写equals()方法
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj != null && obj.getClass() == R.class){
            R r = (R)obj;
            if(r.count == this.count){
                return true;
            }
        }
        return false;
    }
    
    //重写hashCode()方法
    public int hashCode(){
        return this.count;
    }
}

public class TestHashSet {
    public static void main(String[] args) {
        HashSet<R> hs = new HashSet<R>();
        hs.add(new R(5));
        hs.add(new R(-3));
        hs.add(new R(9));
        hs.add(new R(-2));
        
        //打印集合，这时候集合里面还没有重复的元素
        System.out.println(hs);
        
        Iterator<R> it = hs.iterator();
        R first = (R)it.next();
        
        //为第一个元素的count实例变量赋值
        first.count = -3;
        
        //再次输出HashSet集合,集合内有重复的元素
        System.out.println(hs);
        
        //删除count为-3的元素,只被删除了一个元素
        hs.remove(new R(-3));
        System.out.println(hs);
        
        //还是否包含count值为-3的元素
        //很奇怪的是，会输出false
        System.out.println("hs中是否还存在count = -3的元素：" + hs.contains(new R(-3)));
        
        //count值为5 的元素不存在了
        System.out.println("hs中是否包含count值为5 的元素：" + hs.contains(new R(5)));
    }
}

输出的结果是：

[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的元素：false
hs中是否包含count值为5 的元素：false

　　上面的输出结果可能有点让人觉得意外，从输出的结果可知输出的内容已经重复了(有两个-3)，但是因为HashSet把他们添加到了不同的地方，所以HashSet完全可以容纳两个相同的元素。
　　但是当我们试图删除count为-3的R对象的时候，HsahSet会计算出该对象的hsahCode值，从而找出该对象在集合中保存的位置，然后把此处的对象与count为-3的R对象通过equals()方法进行比较，如果相等就删除该对象-----HashSet只有第三个元素才满足该条件(第一个元素实际上是存的count值为5的R 对象对应的位置，所以第三个元素会被删除)。

　　因此在修改HashSet集合中的对象时，应该考虑到，修改有可能导致该对象与集合中的其他对象相等，从而导致HashSet无法准确访问该对象。

同样的情况也会发生在TreeSet中，如果向TreeSet中添加一个可变对象后，后面的程序修改了改可变对象的成员变量，这将导致与其他对象的大小顺序发生改变，但是TreeSet不会再次调整他们的顺序，甚至可能导致这两个对象通过compareTo(Object obj)方法比较返回0.下面的程序演示了这种情况：

import java.util.TreeSet;

class T implements Comparable{
    int count;
    public T(int count) {
        this.count = count;
    }
    
    public String toString(){
        return "T[count:" + count + "]";
    }
    
    //重写equals方法，根据count来判断是否相等
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }
        if (obj != null && obj.getClass() == T.class) {
            T t = (T)obj;
            if(t.count == this.count){
                return true;
            }
        }
        return false;
    }
    
    //重写compareTo()方法，根据count来比较大小
    @Override
    public int compareTo(Object obj){
        T t = (T)obj;
        return count>t.count?1:
            count < t.count?-1:0;
    }
}

public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<T> ts = new TreeSet<T>();
        ts.add(new T(5));
        ts.add(new T(-3));
        ts.add(new T(9));
        ts.add(new T(-2));
        
        System.out.println(ts);
        
        T firs = ts.first();
        firs.count = 20;
        
        //修改后没有排序
        System.out.println(ts);
        
        T last = ts.last();
        last.count = -2;
        
        //将会看到集合里的元素处于无序状态，且有重复的元素
        System.out.println(ts);
        
        //删除count=-2的T对象,将会删除失败
        System.out.println(ts.remove(new T(-2)));
        System.out.println(ts);
        
        //查询是否有count=20的T对象
        System.out.println("是否存在count=20的T对象：" + ts.contains(new T(20)));
    }
}

输出结果：

[T[count:-3], T[count:-2], T[count:5], T[count:9]]
[T[count:20], T[count:-2], T[count:5], T[count:9]]
[T[count:20], T[count:-2], T[count:5], T[count:-2]]
false
[T[count:20], T[count:-2], T[count:5], T[count:-2]]
是否存在count=20的T对象：false

与HashSet类似如果修改了TreeSet中的可变对象，会很容易出错。