1、Comparable 介绍

Comparable 是一个排序接口，如果一个类实现了该接口，说明该类本身是可以进行排序的。注意，除了基本数据类型（八大基本数据类型） 的数组或是List，其余类型的对象，Collections.sort或Arrays.sort 是不支持直接进行排序的，因为对象本身是没有“顺序”的，除非你实现了Comparable 接口或是自定义了Comparable 对象，指定了排序规则，才可以进行排序。

Comparable 源码就一个方法,

public interface Comparable<T> {
     public int compareTo(T o);
 }

泛型T表示要进行比较的对象所属的类型，compareTo 比较对象之间的值的大小关系，如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

定义一个对象：

public class Person implements Comparable<Person>{
  public int age;

  public Person(int age){
    this.age = age;
  }
  public String toString() {
    return "{" +
      "age=" + age +
      '}';
  }
  @Override
  public int compareTo(Person o) {
    //Person 对象之间根据名字排序
    return this.age - o.age;
  }
}

排序测试：

public static void main(String[] args) {
        Person[] ps =new Person[]{new Person(1),new Person(4),
new Person(2),new Person(7),new Person(9),new Person(8),
new Person(3),new Person(0),new Person(1)};
        System.out.println("排序前："+Arrays.toString(ps));
          //进行排序
        Arrays.sort(ps);
        System.out.println("排序后："+Arrays.toString(ps));
    }

排序前：[{age=1}, {age=4}, {age=2}, {age=7}, {age=9}, {age=8}, {age=3}, {age=0}, {age=1}]
排序后：[{age=0}, {age=1}, {age=1}, {age=2}, {age=3}, {age=4}, {age=7}, {age=8}, {age=9}]

2、Comparator 介绍

如果一个类本身并没有实现 Comparable 接口，我们想要对他进行排序，就要自定义 Comparator 比较器进行比较，在这个比较器里面自定义排序的依据。

Comparator 源码中主要的两个接口方法：

public interface Comparator<T>
  {
     int compare(T o1, T o2);
     boolean equals(Object obj);
  }

compare 是主要方法，必须要实现，equals 方法可以不实现。compare 中返回比较结果，如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

定义一个用来排序类，该类并为实现 Comparable 接口：

private static class Man{
    public int age;
    public Man(int age){
        this.age = age;
    }
    public String toString() {
        return "{" +
                "age=" + age +
                '}';
    }
}

进行排序：

@Test
public void test_1(){
        Man[] ps =new Man[]{new Man(1),new Man(4),new Man(2),
                new Man(7),new Man(9),new Man(8),new Man(3),new Man(0),new Man(1)};
        //数组转List
        ArrayList<Man> ap = new ArrayList<Man>(Arrays.asList(ps));

        System.out.println("排序前："+ap);
        //自定义排序器
        Collections.sort(ap,new Comparator<Man>() {
            @Override
            public int compare(Man o1, Man o2) {
              //根据年龄进行排序
                return o1.age - o2.age;
            }
        });

        System.out.println("排序后："+ ap);
}

排序前：[{age=1}, {age=4}, {age=2}, {age=7}, {age=9}, {age=8}, {age=3}, {age=0}, {age=1}]
排序后：[{age=0}, {age=1}, {age=1}, {age=2}, {age=3}, {age=4}, {age=7}, {age=8}, {age=9}]

3、总结比较

Comparable 在类的内部定义排序规则，Comparator 在外部定义排序规则，Comparable 相当于“内部排序器”，Comparator 相当于“外部排序器”，前者一次定义即可，后者可以在不修改源码的情况下进行排序，各有所长。