求解接口Comparator和Comparable的区别(请详细些)？
我的理解是Comparator是用于自定义比较器，而Comparable多数是被其它实现类实现，也就是说定义在内部的比较器是实现Comparable,而自定义的比较器是实现Comparator中的compare(){}方法，不知道这样理解对吗？

Comparator和Comparable都是接口。只是实现Comparable接口的对象说明自身具备比较的功能，String对象就是个很好的例子，比较的规则由对象本来定。Comparator的可以看作一个外在的比较工具，将两个对象放在这个工具内，进行比较，比较的规则是由Comparator而定的。

Comparator和Comparable是没有直接联系的。

当特定情况下需要比较强时，需要实现Comparator接口，如TreeSet(Comparator<? super E> comparator) 需要时,当不指定比较器时，那么对象就要实现Comparable（自身比较功能）接口。

一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：
1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准，比如升序、降序等

1. package cn.temp;
   
2. 
   
3. import java.util.Iterator;
   
4. import java.util.Set;
   
5. import java.util.TreeSet;
   
6. 
   
7. /**
   
8. * 求解接口Comparator和Comparable的区别(请详细些)？
   
9. * @author Cuilitang
   
10. *
    
11. */
    
12. 
    
13. public class Temp {
    
14.         public static void main(String[] args) {
    
15.                 Set<Student> treeset = new TreeSet<Student>();
    
16.                 treeset.add(new Student(1,"张三"));
    
17.                 treeset.add(new Student(2,"李四"));
    
18.                 treeset.add(new Student(3,"王五"));
    
19.                
    
20.                 Iterator<Student> it = treeset.iterator();
    
21.                 while(it.hasNext()){
    
22.                         System.out.println(it.next());
    
23.                 }
    
24.         }
    
25. 
    
26. }
    
27. /*
    
28. * 此程序中Student 对象被存储进treeset集合中，但是treeset集合自身并没有比较对象先后顺序的比较器这样就需要调用对象自身的比较器来进行比较。
    
29. * Person是自定义对象，为了能有比较性必须的继承使对象有比较性特性的接口：Comparable，这种情况很常见，比如要想让对象能够序列化就需要实现Serializable。
    
30. * TreeSet集合是有序的所以迭代出来的元素就是按照Student对象自身的比较器比较的结果.
    
31. * 若想测试，可以修改一下Student类中的compareTo（）试一试。
    
32. */
    
33. class Student implements Comparable<Student>{
    
34.         int id;
    
35.         String name;
    
36.         Student(int id, String name){
    
37.                 this.id = id;
    
38.                 this.name = name;
    
39.         }
    
40.        
    
41.         @Override
    
42.         public int compareTo(Student s1) {           //Student类的自然排序
    
43.                 // TODO Auto-generated method stub
    
44.                 int x = s1.id - this.id;   //比较年龄
    
45.                 int y = s1.name.compareTo(this.name);//比较年龄，String实现了Comparable接口，并重写了conpareTo方法
    
46.                 return x == 0 ? y:x;
    
47.         }
    
48.        
    
49.         @Override
    
50.         public String toString(){
    
51.                 return id + "+" + name +"\t";
    
52.                
    
53.         }
    
54.        
    
55. }
    

复制代码

1. package cn.temp;
   
2. 
   
3. import java.util.Comparator;
   
4. import java.util.Iterator;
   
5. import java.util.Set;
   
6. import java.util.TreeSet;
   
7. 
   
8. /**
   
9. * 求解接口Comparator和Comparable的区别(请详细些)？
   
10. * @author Cuilitang
    
11. *
    
12. */
    
13. 
    
14. public class CopyOfTemp {
    
15.         public static void main(String[] args) {
    
16.                 Set<Teacher> treeset = new TreeSet<Teacher>(new MyComparetor());
    
17.                 treeset.add(new Teacher(1,"张三"));
    
18.                 treeset.add(new Teacher(2,"李四"));
    
19.                 treeset.add(new Teacher(3,"王五"));
    
20.                
    
21.                 Iterator<Teacher> it = treeset.iterator();
    
22.                 while(it.hasNext()){
    
23.                         System.out.println(it.next());
    
24.                 }
    
25.         }
    
26. 
    
27. }
    
28.         class MyComparetor implements Comparator<Teacher>{       //集合的比较器
    
29. 
    
30.                 @Override
    
31.                 public int compare(Teacher t1, Teacher t2) {
    
32.                         // TODO Auto-generated method stub
    
33.                         int x = t1.id - t2.id;
    
34.                         int y = t1.name.compareTo(t2.name);
    
35.                         return x == 0 ? y:x;
    
36.                 }
    
37. }
    
38. /*
    
39. * 此程序中Teacher 对象被存储进treeset集合中.跟上个程序不同，treeset集合自身具有比较器（在new对象时候传入了MyComparetor对象）。
    
40. * 这样就不再要求传入的对象必须自身具备比较性。
    
41. * TreeSet集合迭代出来的元素就是按照MyComparetor比较器比较的结果.
    
42. * 若想测试，可以修改一下MyComparetor类中的compare（）试一试。
    
43. */
    
44. class Teacher{
    
45.         int id;
    
46.         String name;
    
47.         Teacher(int id, String name){
    
48.                 this.id = id;
    
49.                 this.name = name;
    
50.         }
    
51.        
    
52.         @Override
    
53.         public String toString(){
    
54.                 return id + "+" + name +"\t";
    
55.                
    
56.         }
    
57.        
    
58. }
    
59. 
    
60. /**
    
61. *综上所述，Compareable接口和Comparetor接口实现的都是比较功能，两者都可以通过重写方法来对对象的顺序进行比较。
    
62. *但是它们的调用者不同，具体的比较的方法中接受的参数也不同。
    
63. *Compareable是被一个对象调用去与通过参数传进来的另一个对象比较；Comparetor的应用场景到目前为止我所知道的就是在TreeSet集合中，对集合元素进行排序。
    
64. *最后很重要的一点：在Treeset集合中，若是两个比较器同时出现Comparetor优先级高于Compareable。
    
65. */
    

复制代码