最近视频看得比较慢，才看完TreeSet,感觉老师讲的都理解了，也自己写了一遍，但是隐隐约约有感觉有什么不知道似得。总结一下TreeSet就是两个地方吧，1.元素对象没有比较方法，就用让元素类实现Comparable接口。
2。如果没有比较方法，或者已经有比较方法但是不是所需要的，就定义比较器实现Comparator接口，然后TreeSet集合在创建是调用该比较器，如 new TreeSet(new 比较器()) ，通常建议使用这种方法。
3.至于底层结构二叉树我觉得大家都能够理解并记住吧。
就是不知道还有哪些比较重要的点没提到，谁可以来提醒一下呢？

1. import java.util.*;
   
2. class TreeSetDemo1
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 //在集合的构造函数中加入实现了Comparator接口的比较器即只调用该比较器，不再调用元素对象的比较方法
   
7.                 TreeSet ts = new TreeSet(new HeightCompare());
   
8.                 ts.add(new Person("lisi02",15,170));
   
9.                 ts.add(new Person("lisi03",15,165));
   
10.                 ts.add(new Person("lisi03",16,186));
    
11.                 ts.add(new Person("lisi01",15,125));
    
12.                 ts.add(new Person("lisi02",17,185));
    
13.                 ts.add(new Person("lisi04",18,170));
    
14.                 Iterator it = ts.iterator();
    
15.                 while(it.hasNext())
    
16.                 {
    
17.                         Person p = (Person)it.next();
    
18.                         System.out.println("Name: "+p.getName()+" Age: "+p.getAge()+" Height："+p.getHeight());
    
19.                 }
    
20. 
    
21.         }
    
22. }
    
23. //定义身高为主的比较器，如果身高相同则比较年龄
    
24. class HeightCompare implements Comparator
    
25. {
    
26.         public int compare(Object o1,Object o2)
    
27.         {
    
28.                 Person p1 = (Person)o1;
    
29.                 Person p2 = (Person)o2;
    
30.                 int num = new Integer(p1.getHeight()).compareTo(new Integer(p2.getHeight()));
    
31.                 if(num==0)
    
32.                         return p1.getAge()-p2.getAge();
    
33.                 return num;
    
34.                
    
35.         }
    
36. }
    
37. //在元素对象中定义比较器，比较年龄，如果年龄相同则比较姓名的自然顺序
    
38. class Person implements Comparable
    
39. {
    
40.         private String name;
    
41.         private int age;
    
42.         private int height;
    
43.         Person(String name,int age,int height)
    
44.         {
    
45.                 this.name = name;
    
46.                 this.age = age;
    
47.                 this.height = height;
    
48.         }
    
49.         public int getAge()
    
50.         {
    
51.                 return age;
    
52.         }
    
53.         public int getHeight()
    
54.         {
    
55.                 return height;
    
56.         }
    
57.         public String getName()
    
58.         {
    
59.                 return name;
    
60.         }
    
61.         public int compareTo(Object obj)
    
62.         {
    
63.                 Person p = (Person)obj;
    
64.                 int num = this.getAge()-p.getAge();
    
65.                 if(num==0)
    
66.                         return this.getName().compareTo(p.getName());
    
67.                 return num;
    
68.         }
    
69. 
    
70. }
    

复制代码

两种排序要记住！

cbb 发表于 2014-12-3 20:43
两种排序要记住！

什么排序啊？

caobin 发表于 2014-12-3 20:50
什么排序啊？

第一种：实现long包下的Comparable 接口它强制让学生具备比较性。
复写的是compareTo，按照自然顺序排序。
当主要条件相同时，一定要判断下次要条件。

第二种：元素自身不具备比较性时，或者具备的比较性不是所需要的，
这时就需要让集合自身具备比较性。
在集合初始化时候，就定义比较器。实现Comparator接口 复写compare

这个是我以前做的笔记 楼主可以看看希望可以帮到你：

1. /*
   
2.          * TreeSet: 1.向TreeSet中添加的元素必须是同一个类的。
   
3.          * 2.可以按照添加进集合中的元素的指定的顺序遍历。像String，包装类等默认按照从小到大的顺序遍历。
   
4.          * 3.当向TreeSet中添加自定义类的对象时，有两种排序方法：①自然排序②定制排序
   
5.          * 4.自然排序：要求自定义类实现java.lang.Comparable接口并重写其compareTo(Object obj)的抽象方法
   
6.          * 在此方法中，指明按照自定义类的哪个属性进行排序。
   
7.          *
   
8.          * 5.向TreeSet中添加元素时，首先按照compareTo()进行比较，一旦返回0，虽然仅是两个对象的此
   
9.          * 属性值相同，但是程序会认为这两个对象是相同的，进而后一个对象就不能添加进来。
   
10.          *
    
11.          * >compareTo()与hashCode()以及equals()三者保持一致！
    
12.          */
    
13.         @Test
    
14.         public void testTreeSet1() {
    
15.                 Set set = new TreeSet();
    
16.                 // set.add(new String("AA"));
    
17.                 // set.add(new String("AA"));
    
18.                 // set.add("JJ");
    
19.                 // set.add("GG");
    
20.                 // set.add("MM");
    
21.                 // 当Person类没有实现Comparable接口时，当向TreeSet中添加Person对象时，报ClassCastException
    
22.                 set.add(new Person("CC", 23));
    
23.                 set.add(new Person("MM", 21));
    
24.                 set.add(new Person("GG", 25));
    
25.                 set.add(new Person("JJ", 24));
    
26.                 set.add(new Person("KK", 20));
    
27.                 set.add(new Person("DD", 20));
    
28.                 // set.add("AA");
    
29. 
    
30.                 for (Object str : set) {
    
31.                         System.out.println(str);
    
32.                 }
    
33. 
    
34.         }

复制代码

下面是person类

1.         //当向TreeSet中添加Person类的对象时，依据此方法，确定按照哪个属性排列。
   
2.         @Override
   
3.         public int compareTo(Object o) {
   
4.                 if(o instanceof Person){
   
5.                         Person p = (Person)o;
   
6.                         //return this.name.compareTo(p.name);
   
7.                         //return -this.age.compareTo(p.age);
   
8.                         int i = this.age.compareTo(p.age);
   
9.                         if(i == 0){
   
10.                                 return this.name.compareTo(p.name);
    
11.                         }else{
    
12.                                 return i;
    
13.                         }
    
14.                 }
    
15.                 return 0;
    
16.         }
    
17.        

复制代码

哦？{:3_46:}{:3_46:}{:3_46:}

回答的很好 我也受教了
第一种：实现long包下的Comparable 接口它强制让学生具备比较性。
复写的是compareTo，按照自然顺序排序。
当主要条件相同时，一定要判断下次要条件。

第二种：元素自身不具备比较性时，或者具备的比较性不是所需要的，
这时就需要让集合自身具备比较性。
在集合初始化时候，就定义比较器。实现Comparator接口 复写compare

看到TreeSet了，还不加上泛型

我的基础测试的最后一道题貌似和这个类似~