public class CompareByAge implements Comparator{

        
        public int compare(Object o1, Object o2) {
                Person p1=(Person)o1;
                Person p2=(Person)o2;
                if(p1.getAge()>p2.getAge())
                        return 1;
                else if(p1.getAge()<p2.getAge())
                        return -1;
                        else{
                                return p1.getAge()-p2.getAge();
                        }
        }
        
}
在主方法中调用这个方法，可以返回是按年龄大小排序，求高手解释是怎么实现的

是要解释这个方法还是什么?  是解释方法的话 就是这样了
public class CompareByAge implements Comparator{        //自定义一个比较方法    要想比较就需要有该对象有比较性 所以要继承这个 方法上面可以加泛型
        
        public int compare(Object o1, Object o2) {               // 覆写compare方法     
                Person p1=(Person)o1;                                       //如果不加泛型 这里建议判断一下类型
                Person p2=(Person)o2;
                if(p1.getAge()>p2.getAge())                         //这里就没什么好说的了 这个就是比较的书写
                        return 1;                                               //其中这里返回值 为 1 下面的 -1  是排序中按照返回值的正负来判断的  还有0
                else if(p1.getAge()<p2.getAge())
                        return -1;
                        else{
                                return p1.getAge()-p2.getAge();
                        }
        }
        
}

解释这个底层实现，大体的流程我也知道

1. TreeSet排序的第一种方式：
   
2. 让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。也种方式也成为元素的自然顺序，或者叫做默认顺序。
   
3. 
   
4. TreeSet的第二种排序方式。
   
5. 当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
   
6. 在集合初始化时，就有了比较方式。
   
7. 步骤：定义一个类，实现Compartor()接口，覆盖compare方法。把类对象作为初始值传给TreeSet集合的构造函数。
   
8. 当两种排序都存在时，以比较器为主。（自几写的比较器为主，元素自带compareTo方法为次）

复制代码

代码示例如下：

1. import java.util.*;
   
2. class  TreeSetTest
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 TreeSet ts=new TreeSet(new MyCompare());
   
7.                 //ts.add(new Person("a"));
   
8.                 ts.add(new Person("ab"));
   
9.                 ts.add(new Person("ac"));
   
10.                 ts.add(new Person("bbcd"));
    
11.                 ts.add(new Person("abcd"));
    
12.                 ts.add(new Person("adcde"));
    
13.                 ts.add(new Person("acdef"));
    
14. 
    
15.                 for(Iterator it=ts.iterator();it.hasNext();)
    
16.                 {System.out.println(it.next());}
    
17. 
    
18. 
    
19.                
    
20.         }
    
21. }
    
22. 
    
23. class Person
    
24. {
    
25.         private String name;
    
26.         Person(String name){
    
27.         this.name=name;
    
28.         }
    
29.         public void setName(String name){
    
30.         this.name=name;
    
31.         }
    
32.         public String  getName(){
    
33.                 return name;
    
34.         }
    
35.         public String  toString(){
    
36.         return name;}
    
37. }
    
38. 
    
39. class MyCompare implements Comparator
    
40. {
    
41.         public int compare(Object obj1,Object obj2){
    
42.                 if(!(obj1 instanceof Person)&&(obj1 instanceof Person))
    
43.                         throw new RuntimeException("不是学生对象");
    
44.                 Person p1=(Person ) obj1;
    
45.                 Person p2=(Person ) obj2;
    
46.        
    
47.                 int num=new Integer(p1.getName().length()).compareTo(new Integer(p2.getName().length()));
    
48.                
    
49.                 if(num ==0){
    
50.                        
    
51.                         return p1.getName().compareTo(p2.getName());
    
52.                
    
53.                 }
    
54.                
    
55.                 return num;
    
56. 
    
57.         }

复制代码

明天，你好 发表于 2013-5-13 22:15
解释这个底层实现，大体的流程我也知道

TreeSet是一个有序集合，里面的元素若要实现自然排序就需要实现Comparable接口，或者你也可以自定义一个Comparator实现自己的比较方式。TreeSet底层无非是通过比较元素实现排序，那也是调用Comparable或者Comparator来实现的。  其实你可以在覆写的 他的比较方法时候加一个比较方法的输出语句 试试看
如

import java.util.*;
public class TestTreeObject{
public static void main(String[]args){
  TreeSet <String> ts = new TreeSet <String> (new bijiao());
  ts.add("adfgewgsa");
  ts.add("adfgewsdsgsa");
  ts.add("adfgesdfewwgsa");
  ts.add("adfgewsdfgsa");
  ts.add("adfgesdafewrwgsa");
  //ts.add(4546);
  Iterator it = ts.iterator();
  while(it.hasNext()){
   output(it.next());
  }
}
public static void output(Object obj){
  System.out.println(obj);
}
}
class bijiao implements Comparator{

public  int compare(Object obj1,Object obj2){
  String s1 = (String)obj1;
  String s2 = (String)obj2;
  System.out.println("显示");            //这里加个输出语句  你可以看到TreeSet 集合在排序是调用该方法的时候
  return s1.length()-s2.length();
  
}
}

如果问题解决，及时结贴。。把未解决变成以解决