1. import java.util.*;
   
2. import java.lang.*;
   
3. 
   
4. class R implements Comparable
   
5. {
   
6.         int count;
   
7.         public R(int count)
   
8.         {
   
9.            this.count=count;
   
10.         }
    
11.         public String toString()
    
12.         {
    
13.           return "R[count:"+count+"]";
    
14.         }
    
15.         public boolean equals (Object obj)
    
16.         {
    
17.            if (this==obj)
    
18.            {
    
19.                    return true;
    
20.            }
    
21.            if (obj!=null&&obj.getClass()==R.class)
    
22.            {
    
23.                    R r=(R)obj;
    
24.                    if (r.count==this.count)
    
25.                    {
    
26.                            return true;
    
27.                    }
    
28.            }
    
29.                      return false;
    
30.         }
    
31. 
    
32.         public int compareTo(Object obj)
    
33.         {
    
34.            R r =(R)obj;
    
35.            return count>r.count?1: count<r.count?-1:0;
    
36.         }
    
37. }
    
38.   public class Testjihe
    
39.   {
    
40.           public static void main (String[] args)
    
41.           {
    
42.                TreeSet ts=new TreeSet();
    
43.                    ts.add(new R(5));
    
44.           // ts.add(new R(6));    如果去掉斜槓
    
45.                    ts.add(new R(-3));
    
46.                    ts.add(new R(9));
    
47.                    ts.add(new R(-2));
    
48.                    System.out.println(ts);
    
49.                    R first=(R)ts.first();
    
50.                first.count=20;
    
51.                    R last=(R)ts.last();
    
52.                    last.count=-2;
    
53.                    System.out.println(ts);
    
54.                    ts.remove(new R(5));
    
55.              System.out.println(ts);
    
56.             System.out.println(ts.remove(new R(-2)));
    
57. ts.remove(new R(-2));
    
58.                         System.out.println("1"+ts);
    
59. 
    
60.           }
    
61.   }

复制代码

主方法中// ts.add(new R(6));    如果去掉斜槓的話，刪除new R（-2） false，爲什麼呢？

重写equal方法必须重写hashcode方法！所以你懂得

file:///C:\Users\Administrator\AppData\Roaming\Tencent\Users\459787839\QQ\WinTemp\RichOle\9~8Y$8V7VXM}X9VB(U(O4$U.jpg

file:///C:\Users\Administrator\AppData\Roaming\Tencent\Users\459787839\QQ\WinTemp\RichOle\9~8Y$8V7VXM}X9VB(U(O4$U.jpg

因为TreeSet底层为二叉树数据结构，上面程序中的R对象是一个正常重写了equals方法和comparable方法类，这两个方法都以R对象的count属性作为判断的依据。可以看到程序第一次输出的结果是有序排列的。此时小值在左边，大值在右边。

当改变R对象的count属性，程序的输出结果也发生了改变，而且包含了重复元素。一旦改变了TreeSet集合里可变元素的属性，当再试图删除该对象时，TreeSet会先选择5作为节点开始比较，所以count为5的R对象可以删除成功，之后删除count为-2的R对象时，如果有count为6的R对象，则以其为节点比较，比较结果比6小，所以往左边与20比较，发现还小，继续向左，发现没有元素，所以false。

而没有6，则选择最靠近的5的-2作为节点，所以可以删除。

    总结：与HashSet在处理这些对象时将非常复杂，而且容易出错。为了让程序更具健壮，推荐HashSet和TreeSet集合中只放入不可变对象。

刘汉文 发表于 2013-12-30 23:08
因为TreeSet底层为二叉树数据结构，上面程序中的R对象是一个正常重写了equals方法和comparable方法类， ...

高手，谢谢