Comparable 与 Comparator的区别

Comparable & Comparator 都是用来实现集合中元素的比较、排序的，只是 Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。

Comparator位于包java.util下，而Comparable位于包 java.lang下 Comparable 是一个对象本身就已经支持自比较所需要实现的接口（如 String、Integer 自己就可以完成比较大小操作，已经实现了Comparable接口） 自定义的类要在加入list容器中后能够排序，可以实现Comparable接口，在用Collections类的sort方法排序时，如果不指定Comparator，那么就以自然顺序排序， 这里的自然顺序就是实现Comparable接口设定的排序方式。

而 Comparator 是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。 可以说一个是自已完成比较，一个是外部程序实现比较的差别而已。 用 Comparator 是策略模式（strategy design pattern），就是不改变对象自身，而用一个策略对象（strategy object）来改变它的行为。 比如：你想对整数采用绝对值大小来排序，Integer 是不符合要求的，你不需要去修改 Integer 类（实际上你也不能这么做）去改变它的排序行为，只要使用一个实现了 Comparator 接口的对象来实现控制它的排序就行了。

小结：Comparatable接口必须由需要排序的多元素类本身来实现，且在其内部重写comparaTo()方法；Comparator接口是在需要排序的多元素类的外部（即使用外部类）来实现，且必须在该外部类中重写compara()方法。

两者的比较

comparable接口：
• 优点：对于单元素集合可以实现直接排序
• 缺点：对于多元素排序，排序依据是固定不可更改的。（元素内部只能实现一次compareTo方法）

comparator接口：
• 元素的排序依据时刻变的，所以可以通过定义多个外部类的方式来实现不同的排序。使用时按照需求选取。
• 创建外部类的代价太大。

实例：

1、实现Comparable接口（类内部实现比较函数）

需要比较的实体类：

 public class Student implements Comparable<Student> {

     private String name;
     private int age;

     public Student(String name, int age){
         this.name = name;
         this.age  = age;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     @Override//类内部实现比较，因此在数组比较时只要传递一个对象数组
     public int compareTo(Student o) {
         return this.name.compareTo(o.name);
     }

     public String toString(){
         return "Student name ="+name+" age = "+age;
     }

 }

执行排序：

 import java.util.Arrays;

 public class RunComparable {

     public static void main(String args[]){
         Student stu[] = new Student[5];
         stu[0] = new Student("hoojjack",20);
         stu[1] = new Student("hoojj",24);
         stu[2] = new Student("oojjack",19);
         stu[3] = new Student("jjack",21);
         stu[4] = new Student("ack",28);
         for(int i=0;i<stu.length;i++)
             System.out.println(stu[i].toString());
         System.out.println("---------------");
         Arrays.sort(stu);
         for(int i=0;i<stu.length;i++)
             System.out.println(stu[i].toString());
     }

 }

结果：

 //以name排序
 Student name =hoojjack age = 20
 Student name =hoojj age = 24
 Student name =oojjack age = 19
 Student name =jjack age = 21
 Student name =ack age = 28
 ---------------
 Student name =ack age = 28
 Student name =hoojj age = 24
 Student name =hoojjack age = 20
 Student name =jjack age = 21
 Student name =oojjack age = 19

2、实现Comparator接口（需要自己单独新建一个类来写比较方法）

实体类:

 public class Student {

     private String name;
     private int age;

     public Student(String name, int age){
         this.name = name;
         this.age  = age;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     public String toString(){
         return "Student name ="+name+" age = "+age;
     }

单独实现的比较类需要继承Comparator类，以按年龄排序：

 import java.util.Comparator;

 public class StudentComparator implements Comparator<Student> {

     @Override
     public int compare(Student o1, Student o2) {
         if(o1.getAge()>o2.getAge())
             return 1;
         else if(o1.getAge()<o2.getAge())
             return -1;
         else
             return 0;
     }

 }

执行排序：

 import java.util.Arrays;

 public class RunComparable {

     public static void main(String args[]){
         Student stu[] = new Student[5];
         stu[0] = new Student("hoojjack",20);
         stu[1] = new Student("hoojj",24);
         stu[2] = new Student("oojjack",19);
         stu[3] = new Student("jjack",21);
         stu[4] = new Student("ack",28);
         for(int i=0;i<stu.length;i++)
             System.out.println(stu[i].toString());
         System.out.println("---------------");
         Arrays.sort(stu,new StudentComparator());//唯一区别的地方
         for(int i=0;i<stu.length;i++)
             System.out.println(stu[i].toString());
     }

 }

结果：

 //按age排序
 Student name =hoojjack age = 20
 Student name =hoojj age = 24
 Student name =oojjack age = 19
 Student name =jjack age = 21
 Student name =ack age = 28
 ---------------
 Student name =oojjack age = 19
 Student name =hoojjack age = 20
 Student name =jjack age = 21
 Student name =hoojj age = 24
 Student name =ack age = 28

Java源码中的Arrays实现方法：

 //------1------
  public static <T> void sort(T[] a, Comparator<? super T> c) {
         if (c == null) {
             sort(a);
         } else {
             if (LegacyMergeSort.userRequested)
                 legacyMergeSort(a, c);
             else
                 TimSort.sort(a, 0, a.length, c, null, 0, 0);
         }
     }

 //-----2-------
  public static <T> void sort(T[] a, int fromIndex, int toIndex,
                                 Comparator<? super T> c) {
         if (c == null) {
             sort(a, fromIndex, toIndex);
         } else {
             rangeCheck(a.length, fromIndex, toIndex);
             if (LegacyMergeSort.userRequested)
                 legacyMergeSort(a, fromIndex, toIndex, c);
             else
                 TimSort.sort(a, fromIndex, toIndex, c, null, 0, 0);
         }
     }

 //------3------
  static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
                          T[] work, int workBase, int workLen) {
         assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;

         int nRemaining  = hi - lo;
         if (nRemaining < 2)
             return;  // Arrays of size 0 and 1 are always sorted

         // If array is small, do a "mini-TimSort" with no merges
         if (nRemaining < MIN_MERGE) {
             int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
             binarySort(a, lo, hi, lo + initRunLen, c);
             return;
         }

countRunAndMakeAscending函数如4、binarySort函数如5所示

 //-------4--------
  private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
                                                     Comparator<? super T> c) {
         assert lo < hi;
         int runHi = lo + 1;
         if (runHi == hi)
             return 1;

         // Find end of run, and reverse range if descending
         if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
             while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
                 runHi++;
             reverseRange(a, lo, runHi);
         } else {                              // Ascending
             while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
                 runHi++;
         }

         return runHi - lo;
     }

 //--------5-------
  @SuppressWarnings("fallthrough")
     private static <T> void binarySort(T[] a, int lo, int hi, int start,
                                        Comparator<? super T> c) {
         assert lo <= start && start <= hi;
         if (start == lo)
             start++;
         for ( ; start < hi; start++) {
             T pivot = a[start];

             // Set left (and right) to the index where a[start] (pivot) belongs
             int left = lo;
             int right = start;
             assert left <= right;
             /*
              * Invariants:
              *   pivot >= all in [lo, left).
              *   pivot <  all in [right, start).
              */
             while (left < right) {
                 int mid = (left + right) >>> 1;
                 if (c.compare(pivot, a[mid]) < 0)
                     right = mid;
                 else
                     left = mid + 1;
             }
             assert left == right;

             /*
              * The invariants still hold: pivot >= all in [lo, left) and
              * pivot < all in [left, start), so pivot belongs at left.  Note
              * that if there are elements equal to pivot, left points to the
              * first slot after them -- that's why this sort is stable.
              * Slide elements over to make room for pivot.
              */
             int n = start - left;  // The number of elements to move
             // Switch is just an optimization for arraycopy in default case
             switch (n) {
                 case 2:  a[left + 2] = a[left + 1];
                 case 1:  a[left + 1] = a[left];
                          break;
                 default: System.arraycopy(a, left, a, left + 1, n);
             }
             a[left] = pivot;
         }
     }