Java提供了 Comparable 和 Comparator 两个接口，为我们提供了为对象自定义排序逻辑的能力。本文中，我们将探讨 Comparable 和 Comparator 之间的差异，何时如何使用它们。

Comparable 接口：

如下是源码中 Comparable 接口的定义：

package java.lang;

/**
 * 该接口对实现它的每个类的对象强加了总排序。
 * 这种排序称为类的自然排序，而类的compareTo 方法称为其自然比较方法。
 */
public interface Comparable<T> {
    int compareTo(T o);
}

Comparable 接口用于定义对象的自然顺序。若一个类实现了 Comparable 接口，则表明其实例可以相互比较，可以理解为 该类支持排序。

Comparable 接口由一个名为 的方法组成 compareTo()，该方法返回一个表示比较结果的整数值。

compareTo() 方法 返回值/比较结果 的的规则：

• 如果调用对象小于正在比较的对象，则返回负整数。
• 如果调用对象等于正在比较的对象，则为零。
• 如果调用对象大于正在比较的对象，则为正整数。

一个类实现了 Comparable 接口，它就支持自然排序了。

• 可以使用 Arrays.sort() 或 Collections.sort() 方法对保存该对象的集合进行排序。
• 可以不指定比较器直接保存到有序集合（如：TreeSet, TreeMap）中。

注意：

1. 强烈建议（尽管不强制要求）自然排序与 equals 保持一致。
2. null 不是任何类的实例，即使 e.equals(null) 返回 false，e.compareTo(null) 也应该抛出 NullPointerException。

下面的例子定义 Person 类并实现 Comparable 接口：

package cn.itmob.demo;

public class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.age = age;
        this.name = name;
    }
    
    @Override
    public int compareTo(Person o) {
        return this.age - o.getAge();
    }
}

创建保存 Person 实例的集合并排序：

package cn.itmob.demo;

public class SortingExample {
    public static void main(String[] args) {
        Person[] people = {
            new Person("zhang san", 30),
            new Person("li si", 20),
            new Person("wang wu", 40)
        };
        Arrays.sort(people);
        for (Person person : people) {
            System.out.println(person.getName() + ": " + person.getAge());
        }
    }
}

输出排序结果：

li si: 20
zhang san: 30
wang wu: 40

Comparator 接口

如下是源码中 Comparator 接口的定义：

package java.util;

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

// 核心的方法有两个：compare() 和 equals()。
// 从 JDK 1.8 开始新增了多个其他方法对函数式编程进行支持，详见其他文章，这里不过多介绍。

Comparator 接口是比较器接口，提供了一种方法来对未实现 Comparable 接口的对象进行排序，或者为已经实现了 Comparable 接口的对象定义自定义的排序逻辑。Comparator 接口允许您创建单独的比较逻辑，而无需修改原始类。

Comparator 接口定义了一个名为 compare() 的方法，该方法将两个对象作为输入参数并返回一个表示比较结果的整数值。

compare() 方法的返回值/比较结果 的规则与 compareTo() 方法相同：

• 如果第一个对象小于第二个对象，则返回负整数。
• 如果第一个对象等于第二个对象，则返回零。
• 如果第一个对象大于第二个对象，则返回正整数。

下面是 Comparator 接口的实现，根据年龄比较两个 Person 实例：

package cn.itmob.demo;

import java.util.Comparator;

public class NameComparator implements Comparator<Person> {
    @Override
    public int compare(Person person1, Person person2) {
        return person1.getName().compareTo(person2.getName());
    }
}

package cn.itmob.demo;

public class SortingExample {
    public static void main(String[] args) {
        Person zhangSan = new Person("zhang san", 30);
        Person liSi = new Person("li si", 20);
        Person liSi2 = new Person("li si", 40);

        NameComparator comparator = new NameComparator();
        System.out.println(comparator.compare(zhangSan, liSi));
        System.out.println(comparator.compare(liSi, zhangSan));
        System.out.println(comparator.compare(liSi, liSi2));
    }
}

比较结果：

14
-14
0

如何在排序中使用自定义比较器：

package cn.itmob.demo;

public class SortingExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("zhang san", 25),
                new Person("li si", 42),
                new Person("wang wu", 30));

        Collections.sort(people, new NameComparator());

        for (Person person : people) {
            System.out.println(person.getName() + ": " + person.getAge());
        }
    }
}

使用自定义比较器根据名称进行排序的结果：

li si: 42
wang wu: 30
zhang san: 25

如果在排序方法中没有提供比较器，也没有实现 Comparable 接口并重写 compareTo 方法，执行时会出现没有找到任何排序的方法的错误：

SortingExample.java:38: error: no suitable method found for sort(List<Person>)
        Collections.sort(people);
                   ^
method Collections.<T#1>sort(List<T#1>) is not applicable
      (inference variable T#1 has incompatible bounds
        equality constraints: Person
        upper bounds: Comparable<? super T#1>)
    method Collections.<T#2>sort(List<T#2>,Comparator<? super T#2>) is not applicable
      (cannot infer type-variable(s) T#2
        (actual and formal argument lists differ in length))
  where T#1,T#2 are type-variables:
    T#1 extends Comparable<? super T#1> declared in method <T#1>sort(List<T#1>)
    T#2 extends Object declared in method <T#2>sort(List<T#2>,Comparator<? super T#2>)

Comparable 和 Comparator 之间的区别：

• 一个类实现了 Comparable 接口，意味着该它可以直接进行比较/排序，但比较的方式只有这一种。
• 一个类无论是否实现了 Comparable 接口，如果需要进行不同方式的比较/排序，则可以自定义一个或多个比较器（实现 Comparator 接口）。

Comparable 和 Comparator 如何选择呢？

使用 Comparable 还是 Comparator 要根据应用程序实际的要求来选择。

以下是一些规则：

• 如果排序逻辑是要排序的对象固有的并且不会更改，使用 Comparable。
• 如果需要定义多个排序规则或对未实现 Comparable 的对象进行排序时，使用 Comparator。
• 如果一个类实现了 Comparable 接口支持自然排序，仍然可以使用 Comparator 进行自定义排序。

总结：

如果需要基于自然顺序来排序，选择 Comparable，如果要按照对象的不同属性进行排序或需要多种排序逻辑，选择 Comparator。