什么情况下使用Comparator,什么情况下使用Comparable,总是把它们搞混，请大神们用简单易记的语言描述下

让集合自己进行排序用comparator，让类自身有比较性用comparable

Comparable接口用在集合元素是，Comparator用在TreeSet集合本身，当元素不具备比较性，或者元素的比较性不是我们想要的，就要用Comparator, 让集合自身具备比较性。
集合的比较性会覆盖元素的比较性。

TreeSet集合排序有两种方式，Comparable和Comparator区别：a、让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法；
b、让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数；第二种方式较为灵活。，对Set集合中的元素进行排序，底层数据结构是二叉树，当两种排序都存在时，以比较器排序为主;

1. class  TreeSetTest
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 TreeSet ts = new TreeSet(new StrLenComparator());//创建一个TreeSet，并传入一个比较器
   
6. 
   
7.                 ts.add("abcd");//添加元素
   
8.                 ts.add("cc");
   
9.                 ts.add("cba");
   
10.                 ts.add("aaa");
    
11.                 ts.add("z");
    
12.                 ts.add("hahaha");
    
13. 
    
14.                 Iterator it = ts.iterator();//遍历打印这个集合，查看排序结果
    
15.                 while(it.hasNext())
    
16.                 {
    
17.                         System.out.println(it.next());
    
18.                 }
    
19.         }
    
20. }
    
21. class StrLenComparator implements Comparator
    
22. {
    
23.         public int compare(Object o1,Object o2)//覆盖compare方法
    
24.         {
    
25.                 String s1 = (String)o1;
    
26.                 String s2 = (String)o2;
    
27.                        
    
28.                 int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));//字符串按长度从短到长排序
    
29.                 if(num==0)
    
30.                         return s1.compareTo(s2);
    
31.                 return num;
    
32.         }
    
33. }

复制代码

当元素自身不具备比较性，或者具备的比较性不是所需要的,这时需要让容器自身具备比较性;定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数;当两种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖compare方法:

1. import java.util.*;
   
2. class Student implements Comparable//该接口强制让学生具备比较性。
   
3. {
   
4.         private String name;
   
5.         private int age;
   
6. 
   
7.         Student(String name,int age)
   
8.         {
   
9.                 this.name = name;
   
10.                 this.age = age;
    
11.         }
    
12. 
    
13.         public int compareTo(Object obj)
    
14.         {
    
15.                 if(!(obj instanceof Student))
    
16.                         throw new RuntimeException("不是学生对象");
    
17.                 Student s = (Student)obj;
    
18. 
    
19.                 if(this.age>s.age)
    
20.                         return 1;
    
21.                 if(this.age==s.age)
    
22.                         return this.name.compareTo(s.name);
    
23.                 return -1;
    
24.         }
    
25. 
    
26.         public String getName()
    
27.         {
    
28.                 return name;
    
29. 
    
30.         }
    
31.         public int getAge()
    
32.         {
    
33.                 return age;
    
34.         }
    
35. }
    
36. class TreeSetDemo2
    
37. {
    
38.         public static void main(String[] args)
    
39.         {
    
40.                 TreeSet ts = new TreeSet();
    
41. 
    
42.                 ts.add(new Student("lisi02",22));
    
43.                 ts.add(new Student("lisi02",21));
    
44.                 ts.add(new Student("lisi007",20));
    
45.                 ts.add(new Student("lisi09",19));
    
46.                 ts.add(new Student("lisi06",18));
    
47.                 ts.add(new Student("lisi06",18));
    
48.                 ts.add(new Student("lisi007",29));
    
49.           //ts.add(new Student("lisi007",20));
    
50.           //ts.add(new Student("lisi01",40));
    
51. 
    
52.                 Iterator it = ts.iterator();
    
53.                 while(it.hasNext())
    
54.                 {
    
55.                         Student stu = (Student)it.next();
    
56.                         System.out.println(stu.getName()+"..."+stu.getAge());
    
57.                 }
    
58.         }
    
59. }
    
60. 
    
61. class MyCompare implements Comparator
    
62. {
    
63.         public int compare(Object o1,Object o2)
    
64.         {
    
65.                 Student s1 = (Student)o1;
    
66.                 Student s2 = (Student)o2;
    
67. 
    
68.                 int num = s1.getName().compareTo(s2.getName());
    
69.                 if(num==0)
    
70.                         return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
    
71.                 return num;
    
72.         }
    
73. }

复制代码

syw02014 发表于 2014-3-6 18:49
TreeSet集合排序有两种方式，Comparable和Comparator区别：a、让元素自身具备比较性，需要元素对象实现Comp ...

嗯，这个得记清，谢谢哈

这个问题可以这么理解，对你所定义的方法中的元素自身可以比较，那么就必须实现comparable接口，且覆盖compareTo方法，对你所定义方法中的集合自身可以比较，那么就必须实现comparator接口比较器，并且覆盖compare方法，并将该类的方法作为实参返回给集合的构造函数。

这个问题可以这么理解，对你所定义的方法中的元素自身可以比较，那么就必须实现comparable接口，且覆盖compareTo方法，对你所定义方法中的集合自身可以比较，那么就必须实现comparator接口比较器，并且覆盖compare方法，并将该类的方法作为实参返回给集合的构造函数。