一、概述。
Comparator和Comparable两者都属于集合框架的一部分，都是用来在对象之间进行比较的，但两者又有些许的不同，我们先通过一个例子来看一下他们的区别，然后再分别学习下它们的源码。
先来看一下Comparable的例子，定义实体类Student，实现Comparable，重写compareTo方法：
public class Student implements Comparable<Student> { private String name; private Integer age; private Integer score; public Student(String name, Integer age, Integer score) { this.name = name; this.age = age; this.score = score; } @Override public int compareTo(Student o) { return this.getName().compareTo(o.getName()); } } 进行测试：
public static void main(String[] args) { Student student1 = new Student("zhangsan", 1, 80); Student student2 = new Student("lisi", 3, 90); Student student3 = new Student("wangwu", 2, 100); List<Student> list = new ArrayList<>(); list.add(student1); list.add(student2); list.add(student3); Collections.sort(list); list.stream().forEach(n -> System.out.println(n.toString())); } output：
Student{name='lisi', age=3, score=90} Student{name='wangwu', age=2, score=100} Student{name='zhangsan', age=1, score=80} 从上面的例子我们大致了解了Comparable接口的使用，也就是说同一个类的对象之间如果要进行比较，需要实现Comparable接口，并且实现compareTo方法。这样比较的时候就会按照这个规则来进行比较。
再来看一下Comparator的例子，定义实体类Student，
public class Student { private String name; private Integer age; private Integer score; public Student(String name, Integer age, Integer score) { this.name = name; this.age = age; this.score = score; } } 自定义比较器：
class AgeComparator 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; } } } class NameComparator implements Comparator<Student> { @Override public int compare(Student o1, Student o2) { return o1.getName().compareTo(o2.getName()); } } 进行测试：
public static void main(String[] args) { Student student1 = new Student("zhangsan", 1, 80); Student student2 = new Student("lisi", 3, 90); Student student3 = new Student("wangwu", 2, 100); List<Student> list = new ArrayList<>(); list.add(student1); list.add(student2); list.add(student3); // 这时候如果直接 Collections.sort(list) 会由于Student没有默认的自然排序，编译不过。 Collections.sort(list, new AgeComparator()); list.stream().forEach(n -> System.out.println(n.toString())); System.out.println("\n-------------------"); Collections.sort(list, new NameComparator()); list.stream().forEach(n -> System.out.println(n.toString())); } 先按照AgeComparator比较规则进行比较，再按照NameComparator比较器进行比较，output：
Student{name='zhangsan', age=1, score=80} Student{name='wangwu', age=2, score=100} Student{name='lisi', age=3, score=90} ------------------- Student{name='lisi', age=3, score=90} Student{name='wangwu', age=2, score=100} Student{name='zhangsan', age=1, score=80} 可以看到，我们如果要对实体类的对象进行比较，在不修改原实体类的情况下，可以通过实现多个Comparator来实现多个比较规则。通过Comparator，我们可以自定义比较规则，针对对象的属性或者字段等来进行比较，而Comparable就实现不了，因为它的compareTo方法只能有一种比较规则。
实现Comparator，同样也要实现它的一个方法compare。由于一般情况下我们实现的Comparator只有一个compare方法，所以我们可以对实现类进行一些优化：
- 使用匿名类来代替单独的实现类。比如我们可以将
Collections.sort(list, new NameComparator());替换为：
Collections.sort(list, new Comparator<Student>() { @Override public int compare(Student o1, Student o2) { return o1.getName().compareTo(o2.getName()); } });
- 借助JDK1.8的lambda表达式，进一步优化为：
Collections.sort(list, (o1, o2) -> o1.getName().compareTo(o2.getName()));
- 借助JDK1.8中Comparator接口中的新的方法comparing，再次优化：
Collections.sort(list, Comparator.comparing(Student::getName)); 区别
了解了他们的简单使用之后，我们可以来简单分析一下他们的区别了。
相同点：
- 两者都是用来用作对象之间的比较，都可以自定义比较规则；
- 两者都是返回一个描述对象之间关系的int；
不同点：
- 实现了Comparable的意思是
我可以把自己和另一个对象进行比较；而实现了Comparator的意思是我可以比较其他两个对象；也就是说Comparable是一个可比较的对象可以将自己与另一个对象进行比较；而Comparator是比较两个不同的对象。- 使用Comparable需要修改原先的实体类，是属于一种自然排序。而Comparator则不用修改原先类。
- 即使修改了Comparable实体类，Comparable也仅有一种比较规则。而Comparator可以实现多个，来提供多个比较规则。
下面来看一下各自的源码，由于都是接口，我们主要看下JDK1.8之后的默认实现方法。
Comparable
Comparable就比较简单了，只有一个compareTo方法。我们实现该方法的时候注意一下对象的NPE（NullPointerException）问题就可以了。
Comparator
Comparator除了默认的compare和equals接口之外，其他的基本都是默认实现方法。我们来看一下这些方法的实现。
reversed方法
返回逆序比较的比较器，这个就很简单，底层直接使用Collections的reverseOrder来实现。
default Comparator<T> reversed() { return Collections.reverseOrder(this); } thenComparing
这个方法是多条件排序的方法，当我们排序的条件不止一个的时候可以使用该方法。比如说我们对Student先按照age字段排序，再按照score排序，就可以使用thenComparing方法：
Student student1 = new Student("zhangsan", 1, 80); Student student2 = new Student("lisi", 3, 90); Student student3 = new Student("wangwu", 2, 100); Student student4 = new Student("tom", 3, 75); List<Student> list = new ArrayList<>(); list.add(student1); list.add(student2); list.add(student3); list.add(student4); Collections.sort(list, Comparator.comparing(Student::getAge).thenComparing(Student::getScore)); list.stream().forEach(n -> System.out.println(n.toString())); output：
Student{name='zhangsan', age=1, score=80} Student{name='wangwu', age=2, score=100} Student{name='tom', age=3, score=75} Student{name='lisi', age=3, score=90} 如果有需要，我们可以借助这个方法构造更复杂的排序方式。该方法有多个重载的方法，并且有几个支持各种类型的方法如：
default <U> Comparator<T> thenComparing( Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator) default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) { return thenComparing(comparingInt(keyExtractor)); } 不过，底层调用的全是同样的方法：
default Comparator<T> thenComparing(Comparator<? super T> other) { Objects.requireNonNull(other); return (Comparator<T> & Serializable) (c1, c2) -> { int res = compare(c1, c2); return (res != 0) ? res : other.compare(c1, c2); }; } reverseOrder和naturalOrder
naturalOrder是返回自然排序的比较器，reverseOrder恰好和naturalOrder相反，两者都是用于返回实现了Comparable接口的对象的比较器。我们借助刚才Comparator和Comparable两者进行比较时的Comparable的代码，来测试一下，先看一下自然顺序，结果和原来一样：
Collections.sort(list, Comparator.naturalOrder()); output：
Student{name='lisi', age=3, score=90} Student{name='wangwu', age=2, score=100} Student{name='zhangsan', age=1, score=80} 再看一下逆序：
Collections.sort(list, Comparator.reverseOrder()); output：
Student{name='zhangsan', age=1, score=80} Student{name='wangwu', age=2, score=100} Student{name='lisi', age=3, score=90} 这两个方法说白了就是将Comparable的方式转换为Comparator，因为Comparable的功能有限，不方便我们基于Comparable进行扩展。底层实现分别借助于工具类Collections及Comparators来实现。Comparators是专门用于支持Comparator的内部类。
public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() { return Collections.reverseOrder(); } public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() { return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE; } nullsFirst和nullsLast方法
这两个方法有点意思，是说如果排序的字段为null的情况下这条记录怎么排序。nullsFirst是说将这条记录排在最前面，而nullsLast是说将这条记录排序在最后面。举个例子就可以了：
public static void main(String[] args) { Student student1 = new Student("zhangsan", 1, 80); Student student2 = new Student("lisi", null, 90); Student student3 = new Student("wangwu", 2, 100); List<Student> list = new ArrayList<>(); list.add(student1); list.add(student2); list.add(student3); Comparator<Student> comparator = Comparator.comparing(Student::getAge, Comparator.nullsLast(Comparator.reverseOrder())); Collections.sort(list, comparator); list.stream().forEach(n -> System.out.println(n.toString())); } 按照age进行逆序排列，将key为null的排到最后面，output：
Student{name='wangwu', age=2, score=100} Student{name='zhangsan', age=1, score=80} Student{name='lisi', age=null, score=90} 按照age进行自然顺序排列，将key为null的排再最前面：
Comparator<Student> comparator = Comparator.comparing(Student::getAge, Comparator.nullsFirst(Comparator.naturalOrder())); Collections.sort(list, comparator); output：
Student{name='lisi', age=null, score=90} Student{name='zhangsan', age=1, score=80} Student{name='wangwu', age=2, score=100} 如果多个key都为null的话，那将无法保证这几个对象的排序。
源码很简单，直接通过Comparators内部类实现的。
public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) { return new Comparators.NullComparator<>(true, comparator); } public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) { return new Comparators.NullComparator<>(false, comparator); } comparing方法
comparing方法我们已经用过，就是获取对象的比较器也就是比较规则，有几个重载方法及对应类型的方法，第一个参数接受的是函数式表达式。我们使用例子来看下：
因为前些时候用到了布尔类型的排序，所以我们这次就拿Boolean类型的排序来进行测试。修改原先Student类，添加一个布尔类型字段likeGame，然后测试下：
public static void main(String[] args) { List<Student> list = Arrays.asList( new Student("zhangsan", 1, 80, true), new Student("wangwu", 3, 100, false), new Student("zisi", 4, 110, true), new Student("zisi", 2, 110, true) ); Collections.sort(list, Comparator.comparing(Student::getLikeGame).thenComparing(Student::getAge)); list.stream().forEach(n -> System.out.println(n.toString())); } output：
Student{name='wangwu', age=3, score=100, likeGame=false} Student{name='zhangsan', age=1, score=80, likeGame=true} Student{name='zisi', age=2, score=110, likeGame=true} Student{name='zisi', age=4, score=110, likeGame=true} 这就实现了按照Student对象的likeGame进行自然排序，同样，两个参数的接口，第二个参数可以指定具体的比较规则：
Collections.sort(list, Comparator.comparing(Student::getLikeGame, Comparator.reverseOrder()) .thenComparing(Student::getAge)); list.stream().forEach(n -> System.out.println(n.toString())); 这就实现了按照逆序对likeGame进行排序，output：
Student{name='zhangsan', age=1, score=80, likeGame=true} Student{name='zisi', age=2, score=110, likeGame=true} Student{name='zisi', age=4, score=110, likeGame=true} Student{name='wangwu', age=3, score=100, likeGame=false} 简单说下，Boolean类型的排序默认规则是false排在前面，而true排在后面，原因我们可以看下Boolean的compare方法。
public int compareTo(Boolean b) { return compare(this.value, b.value); } public static int compare(boolean x, boolean y) { return (x == y) ? 0 : (x ? 1 : -1); } comparing接口的源码可以简单看下，其中一个源码如下：
public static <T, U extends Comparable<? super U>> Comparator<T> comparing( Function<? super T, ? extends U> keyExtractor) { Objects.requireNonNull(keyExtractor); return (Comparator<T> & Serializable) (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2)); } 总结
Comparator和Comparable这两个接口，一般只要我们涉及到集合的排序，都少不了要与这两个接口打交道，而平时我们使用Comparator很显然会更多一些，所以本篇文章主要学习了下两者的使用，区别，并看了看源码，学习了JDK8之后Comparator增加的一些方法。
其实Comparator的方法不太多，总结一下就几种：
- comparing获取比较器，thenComparing多条件比较器；
- reverseOrder与naturalOrder用于Comparable向Comparator的转换；
- nullsFirst和nullsLast用于处理排序字段为null的情况；
- 剩余的就是原先的compare和equals方法。
另外使用这两个接口的过程中，需要注意的点就是对null的检测，处理。
##################################################################################
不同点。
1、自然排序，定制排序。
2、
3、
4、
注意。
1、由于 null 不是一个类，也不是一个对象，因此在重写 compareTo 方法时应该注意 e.compareTo(null) 的情况，即使 e.equals(null) 返回 false，compareTo 方法也应该主动抛出一个空指针异常 NullPointerException。
2、
京公网安备 11010502036488号