//以下代码是想撤销TreeSet集合的排序功能，但依旧保留唯一性

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;


public class LoopCircle {
        public static void main(String args[])
        {
                TreeSet<Integer> circle=null;;
                circle=new TreeSet<Integer>(new FormerOrder());       
                int num[]={5,4,3,2,1};
               
                //向set集合中添加两次数组
                for(int i=0;i<5;i++){
                        System.out.println(num+"添加：："+circle.add(num));
                }
               
                for(int i=0;i<5;i++){
                        System.out.println(num+"添加：："+circle.add(num));
                }
               
                if(circle!=null){
                        Iterator<Integer> iter=circle.iterator();
                        System.out.print("[");
                        while(iter.hasNext()){
                                System.out.print(iter.next()+"  ");
                        }
                        System.out.print("]");
                }
        }
}

class FormerOrder implements Comparator<Integer>        //自定义比较器
{
        public int compare(Integer o1,Integer o2)
        {
                if(o1==o2)
                {
                        return 0;
                }else {
                        return 1;
                }
                //return o1.compareTo(o2);
        }
}





这运行结果是什么情况！~~~

class FormerOrder implements Comparator<Integer>        //自定义比较器
{
        public int compare(Integer o1,Integer o2)
        {
                if(o1==o2)
                {
                                        System.out.println(o1+"......"+o2);
                        return 0;
                }else {
                                        System.out.println(o1+"====="+o2);
                        return 1;
                }
                //return o1.compareTo(o2);
        }
}

往楼主代码里加入了两条输出语句，结果如下：
5......5
5添加：：true
4=====5
4添加：：true
3=====5
3=====4
3添加：：true
2=====4
2=====3
2添加：：true
1=====4
1=====3
1=====2
1添加：：true
5=====4
5=====2
5=====1
5添加：：true
4......4
4添加：：false
3=====4
3=====2
3=====1
3=====5
3添加：：true
2=====4
2......2
2添加：：false
1=====4
1=====2
1=====5
1=====3
1添加：：true
[5  4  3  2  1  5  3  1  ]
发现，添加的时候，这个元素先和谁比不确定，但是不相同都return 1往右走，无法和TreeSet集合中所有的元素比一遍，因此才会出现上述问题的吧？
个人认为这是因为二叉树的数据结构决定的，楼主可供参考

如果非要让TreeSet去除其排序功能，只保留其去除重复功能，鄙人不才，添加了些代码，但是其实也就失去了TreeSet集合的意义吧

1. //以下代码是想撤销TreeSet集合的排序功能，但依旧保留唯一性
   
2. 
   
3. import java.util.*;
   
4. public class LoopCircle {
   
5.         public static void main(String args[])
   
6.         {
   
7.                                 //TreeSet<Integer> temp = new TreeSet<Integer>();//创建一个临时容器，保持和下面的circle“同步”
   
8.                                 ArrayList<Integer> temp = new ArrayList<Integer>();//用ArrayList也可以
   
9. 
   
10.                 TreeSet<Integer> circle=null;;
    
11.                 circle=new TreeSet<Integer>(new FormerOrder(temp));      
    
12.                 int num[]={5,4,3,2,1};
    
13.                
    
14.                 //向set集合中添加两次数组
    
15.                 for(int i=0;i<5;i++){
    
16.                                                 
    
17.                         System.out.println(num[i]+"添加：："+circle.add(num[i]));
    
18.                                                 temp.add(num[i]);//每往circle里面添加一个元素，就往temp里面添加一个元素
    
19.                 }
    
20.                
    
21.                 for(int i=0;i<5;i++){
    
22.                                                 
    
23.                         System.out.println(num[i]+"添加：："+circle.add(num[i]));
    
24.                                                 temp.add(num[i]);
    
25.                 }
    
26.                
    
27.                 if(circle!=null){
    
28.                         Iterator<Integer> iter=circle.iterator();
    
29.                         System.out.print("[");
    
30.                         while(iter.hasNext()){
    
31.                                 System.out.print(iter.next()+"  ");
    
32.                         }
    
33.                         System.out.print("]");
    
34.                 }
    
35.         }
    
36. }
    
37. 
    
38. class FormerOrder implements Comparator<Integer>        //自定义比较器
    
39. {
    
40.                 private ArrayList<Integer> temp;
    
41.                 FormerOrder(ArrayList<Integer> temp)//构造时，传入temp使其“监视”temp里面都有哪些元素
    
42.                 {
    
43.                         this.temp = temp;
    
44.                 }
    
45.         public int compare(Integer o1,Integer o2)
    
46.         {
    
47.                 if(temp.contains(o1))
    
48.                 {
    
49.                                        // System.out.println(o1+"......"+o2);
    
50.                         return 0;
    
51.                 }else {
    
52.                                         //System.out.println(o1+"====="+o2);
    
53.                         return 1;
    
54.                 }
    
55.                 //return o1.compareTo(o2);
    
56.         }
    
57. }

复制代码

顶帖，拿币，走人