Comparator与Comparable有什么区别呀？怎么用呀？高手用代码解决

comparable和Comparator  都可以用来实现排序：
Comparable是在集合内部定义的方法实现的排序，需在集合内实现Comparable接口的方法compareTo();
Comparator是在集合外部实现的排序，需要在集合外定义Comparator接口的方法compare();
Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String    Integer自己就可以完成比较大小操作）;   
Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。

下面两篇代码是分别用两个接口来实现了同样的目的

目的是：在TreeSet中加入对象元素，并对其中元素进行排序，假如出现学号相同则按名字字母的先后排序。

1. import   java.util.Iterator;
   
2. import   java.util.TreeSet;
   
3. class   TreeSetTest
   
4. {
   
5. public   static   void   main(String[]   args)
   
6. {
   
7. TreeSet <Object>   ts=new   TreeSet <Object> ();
   
8. 
   
9. ts.add(new   MyStudents(2, "Vida "));
   
10. ts.add(new   MyStudents(4, "Lillian "));
    
11. ts.add(new   MyStudents(2, "Lightmoon "));
    
12. ts.add(new   MyStudents(1, "Chaner "));
    
13. 
    
14. Iterator   it=ts.iterator();
    
15. while(it.hasNext())
    
16. {
    
17. System.out.println(it.next());
    
18. }
    
19. 
    
20. }
    
21. 
    
22. }
    
23. 
    
24. class   MyStudents   implements   Comparable <Object>
    
25. {
    
26. int   number;
    
27. String   name;
    
28. MyStudents(int   number,String   name)
    
29. {
    
30. this.number=number;
    
31. this.name=name;
    
32. }
    
33. public   String   toString()
    
34. {
    
35. return   "The   Student 's   information   is:   Number= "+number+ "   name= "+name;
    
36. }
    
37. public   int   compareTo(Object   o)
    
38. {
    
39. MyStudents   mst=(MyStudents)o;
    
40. int   result;
    
41. result=number   >   mst.number   ?   1   :   (number==mst.number   ?   0   :   -1);
    
42. if(result==0)
    
43. {
    
44. return   result=name.compareTo(mst.name);
    
45. }
    
46. return   result;
    
47. }
    
48. }
    

复制代码

1. import   java.util.*;
   
2. class   TreeSetTest_1
   
3. {
   
4. public   static   void   main(String[]   args)
   
5. {
   
6. TreeSet <Object>   ts=new   TreeSet <Object> (new   MyStudents.MyStudentsComparator());
   
7. 
   
8. ts.add(new   MyStudents(2, "Vida "));
   
9. ts.add(new   MyStudents(4, "Lillian "));
   
10. ts.add(new   MyStudents(2, "Lightmoon "));
    
11. ts.add(new   MyStudents(1, "Chaner "));
    
12. 
    
13. Iterator   it=ts.iterator();
    
14. while(it.hasNext())
    
15. {
    
16. System.out.println(it.next());
    
17. }
    
18. 
    
19. }
    
20. 
    
21. }
    
22. 
    
23. class   MyStudents
    
24. {
    
25. int   number;
    
26. String   name;
    
27. MyStudents(int   number,String   name)
    
28. {
    
29. this.number=number;
    
30. this.name=name;
    
31. }
    
32. public   String   toString()
    
33. {
    
34. return   "The   Student 's   information   is:   Number= "+number+ "   name= "+name;
    
35. }
    
36. 
    
37. static   class   MyStudentsComparator   implements   Comparator <Object>
    
38. {
    
39. public   int   compare(Object   o1,Object   o2)
    
40. {
    
41. MyStudents   mst1=(MyStudents)o1;
    
42. MyStudents   mst2=(MyStudents)o2;
    
43. int   result=mst1.number> mst2.number?1:(mst1.number==mst2.number?0:-1);
    
44. if(result==0)
    
45. {
    
46. return   mst1.name.compareTo(mst2.name);
    
47. }
    
48. return   result;
    
49. }
    
50. 
    
51. }
    
52. 
    
53. }

复制代码

一个是lang包下面的接口,一个是util包下面的接口,看起来两个是实现相同的目的,但两者还是有区别的,
1.Comparable <T> 只有一个要实现的方法叫CompareTo
而Comparator <T> 取有两个方法.一个是Compare和equals
2Comparable是一个参数的.而且他是系统调用的方法.所以他只能表示传入对象与当前对象的比较
而Comparator是两个参数的,虽然也是系统调用的方法,不过他的比较就可以不是当前对象于传入对象的比较了,范围就大多了.

当需要排序的集合或数组不是单纯的数字型时，通常可以使用Comparator或Comparable，以简单的方式实现对象排序或自定义排序。
一、Comparator
强行对某个对象collection进行整体排序的比较函数，可以将Comparator传递给Collections.sort或Arrays.sort。
接口方法：
Java代码

• /**
• * @return o1小于、等于或大于o2，分别返回负整数、零或正整数。
• */  
• int compare(Object o1, Object o2);  
  

  /**   * @return o1小于、等于或大于o2，分别返回负整数、零或正整数。   */  int compare(Object o1, Object o2);案例：Java代码

• import java.util.Arrays;  
• import java.util.Comparator;  
•   
• public class SampleComparator implements Comparator {  
•   
•   public int compare(Object o1, Object o2) {  
•     return toInt(o1) - toInt(o2);  
•   }  
•   
•   private int toInt(Object o) {  
•     String str = (String) o;  
•     str = str.replaceAll("一", "1");  
•     str = str.replaceAll("二", "2");  
•     str = str.replaceAll("三", "3");  
•     //   
•     return Integer.parseInt(str);  
•   }  
•   
•   /**
•    * 测试方法
•    */  
•   public static void main(String[] args) {  
•     String[] array = new String[] { "一二", "三", "二" };  
•     Arrays.sort(array, new SampleComparator());  
•     for (int i = 0; i < array.length; i++) {  
•       System.out.println(array);  
•     }  
•   }  
•   
• }  
  

import java.util.Arrays;import java.util.Comparator;public class SampleComparator implements Comparator {  public int compare(Object o1, Object o2) {    return toInt(o1) - toInt(o2);  }  private int toInt(Object o) {    String str = (String) o;    str = str.replaceAll("一", "1");    str = str.replaceAll("二", "2");    str = str.replaceAll("三", "3");    //     return Integer.parseInt(str);  }  /**   * 测试方法   */  public static void main(String[] args) {    String[] array = new String[] { "一二", "三", "二" };    Arrays.sort(array, new SampleComparator());    for (int i = 0; i < array.length; i++) {      System.out.println(array);    }  }}二、Comparable
强行对实现它的每个类的对象进行整体排序，实现此接口的对象列表（和数组）可以通过Collections.sort或Arrays.sort进行自动排序。
接口方法：
Java代码

• /**
• * @return 该对象小于、等于或大于指定对象o，分别返回负整数、零或正整数。  
• */  
• int compareTo(Object o);  
  

  /**   * @return 该对象小于、等于或大于指定对象o，分别返回负整数、零或正整数。    */  int compareTo(Object o);
假设对象User，需要按年龄排序：
Java代码

• public class User {  
•   
•   private String id;  
•   private int age;  
•   
•   public User(String id, int age) {  
•     this.id = id;  
•     this.age = age;  
•   }  
•   
•   public int getAge() {  
•     return age;  
•   }  
•   
•   public void setAge(int age) {  
•     this.age = age;  
•   }  
•   
•   public String getId() {  
•     return id;  
•   }  
•   
•   public void setId(String id) {  
•     this.id = id;  
•   }  
•   
• }  
  

public class User {  private String id;  private int age;  public User(String id, int age) {    this.id = id;    this.age = age;  }  public int getAge() {    return age;  }  public void setAge(int age) {    this.age = age;  }  public String getId() {    return id;  }  public void setId(String id) {    this.id = id;  }}改造后的对象：
Java代码

• import java.util.Arrays;  
•   
• public class User implements Comparable {  
•   
•   private String id;  
•   private int age;  
•   
•   public User(String id, int age) {  
•     this.id = id;  
•     this.age = age;  
•   }  
•   
•   public int getAge() {  
•     return age;  
•   }  
•   
•   public void setAge(int age) {  
•     this.age = age;  
•   }  
•   
•   public String getId() {  
•     return id;  
•   }  
•   
•   public void setId(String id) {  
•     this.id = id;  
•   
•   }  
•   
•   public int compareTo(Object o) {  
•     return this.age - ((User) o).getAge();  
•   }  
•   
•   /**
•    * 测试方法
•    */  
•   public static void main(String[] args) {  
•     User[] users = new User[] { new User("a", 30), new User("b", 20) };  
•     Arrays.sort(users);  
•     for (int i = 0; i < users.length; i++) {  
•       User user = users;  
•       System.out.println(user.getId() + " " + user.getAge());  
•     }  
•   }  
•   
• }  
  

import java.util.Arrays;public class User implements Comparable {  private String id;  private int age;  public User(String id, int age) {    this.id = id;    this.age = age;  }  public int getAge() {    return age;  }  public void setAge(int age) {    this.age = age;  }  public String getId() {    return id;  }  public void setId(String id) {    this.id = id;  }  public int compareTo(Object o) {    return this.age - ((User) o).getAge();  }  /**   * 测试方法   */  public static void main(String[] args) {    User[] users = new User[] { new User("a", 30), new User("b", 20) };    Arrays.sort(users);    for (int i = 0; i < users.length; i++) {      User user = users;      System.out.println(user.getId() + " " + user.getAge());    }  }}三、Comparator和Comparable的区别
先看一下使用Comparator对User集合实现排序的方式：
Java代码

• import java.util.Arrays;  
• import java.util.Comparator;  
•   
• public class UserComparator implements Comparator {  
•   
•   public int compare(Object o1, Object o2) {  
•     return ((User) o1).getAge() - ((User) o2).getAge();  
•   }  
•   
•   /**
•    * 测试方法
•    */  
•   public static void main(String[] args) {  
•     User[] users = new User[] { new User("a", 30), new User("b", 20) };  
•     Arrays.sort(users, new UserComparator());  
•     for (int i = 0; i < users.length; i++) {  
•       User user = users;  
•       System.out.println(user.getId() + " " + user.getAge());  
•     }  
•   }  
•   
• }  
  

import java.util.Arrays;import java.util.Comparator;public class UserComparator implements Comparator {  public int compare(Object o1, Object o2) {    return ((User) o1).getAge() - ((User) o2).getAge();  }  /**   * 测试方法   */  public static void main(String[] args) {    User[] users = new User[] { new User("a", 30), new User("b", 20) };    Arrays.sort(users, new UserComparator());    for (int i = 0; i < users.length; i++) {      User user = users;      System.out.println(user.getId() + " " + user.getAge());    }  }}
一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：
1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准，比如升序、降序等

Comparable  应该是集合自身就具备比较性，但是比较方式不是你想要的，这时候你就可以实现 Comparable，复写CompareTo方法，定义自己的比较方式，比如TreeSet集合是实现自然排序的。如果你不想自然排序就实现Comparable接口。

Comparator 集合存入的数据本身不具备比较性， Comparator能强制实现比较。只要在集合声明比较器就可以了， 个人理解、

这个问题百度可以解决

当元素自身具备比较性时。元素可以实现comparable接口，重写compareTo方法。这种方式就是元素的自然顺序，或者叫默认数序。
当元素自身不具备比较性，或具备的比较性不是所需要的，这时就需要集合自身具备比较性，在集合初始化时就有了比较性。
即定义一个比较器： 实现comparator接口，重写compare方法
如果同时存在comparable和comparator  以比较器为主

Comparator:强行对某个对象collection进行整体排序的比较函数，可以将Comparator传递给Collections.sort或Arrays.sort。

Comparable:强行对实现它的每个类的对象进行整体排序，实现此接口的对象列表（和数组）可以通过Collections.sort或Arrays.sort进行自动排序。


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