Java中comparable 和 comparator

comparable 和 comparator是Java中针对排序的两个接口，而作用的对象是一个具体的实例类。比如一个Human类：

class Human {
    private String name;
    private int age;

    public Human(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;
    }
}

这两个接口的使用方式有所不同，具体的不同可以通过Java中 Collections 中的 sort 方法可以看出。Collections 中 sort 方法有两个多态形式：

public static <T extends Comparable<? super T>> void sort(List<T> list)
public static <T> void sort(List<T> list, Comparator<? super T> c)

1. Comparator 用法

从这两个重载方法可以看出 Comparator 的作用是作为参数传给 sort 方法用于排序方式的确定。比如我们定义一个 Comparator 类：

import java.util.Comparator;

public class HumanComparator implements Comparator<Human>{
    @Override
    public int compare(Human o1, Human o2) {
        return o1.getAge() - o2.getAge();
    }
}

这个 Comparator类说明Human数组或者列表（List）根据 age 属性进行升序排序。

public static void main(String[] args) {

        List<Human> humans = new ArrayList<>();
        humans.add(new Human("Sarah", 10));
        humans.add(new Human("Jack", 12));
        humans.add(new Human("Jack", 10));

        Collections.sort(humans, new HumanComparator());
    }

这样就可以根据 HumanComparator中定义的 compare 方法对 humans 列表进行排序。

2. Comparable 的用法

那么Comparable该如何用呢？Comparable接口主要用于需要排序的实例类实现其中的 compareTo 方法。比如针对 Human 类，我们实现 Comparable 接口：

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

    public Human(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(Human o) {
        return this.age - o.getAge();
    }
}

依然是升序排序，这是如果我们再使用 Collections.sort 方法就不需要 Comparator 实例了，而是直接通过第一种多态形式进行调用：

public static void main(String[] args) {

        List<Human> humans = new ArrayList<>();
        humans.add(new Human("Sarah", 10));
        humans.add(new Human("Jack", 12));
        humans.add(new Human("Jack", 10));

        Collections.sort(humans);
    }

3. 二种形式的比较

    既然有两种排序的实现形式，那我们应该使用哪种呢？

    从 Comparable 的实现方式，我们可以看出，如果我们需要改变排序的规则，比如使用 age 属性倒序排序，那么我们只能修改 Human 中的 compareTo 代码。而如果我们想使用 name 属性来进行排序，那么有需要修改 Human 中的代码。因此 Comparable 方式代码的可扩展性很差，每次修改我们必须修改 Human 类的源代码。

    再来看看 Comparator 的实现方式，因为 HumanComparator 是完全独立于 Human 而存在的，所以每次我们想修改排序规则时，只需要再重新定义一个 HumanComparator ,比如使用 name 属性排序，那么我们就定义 HumanComparatorByName :

public class HumanComparatorByName implements Comparator<Human>{
    @Override
    public int compare(Human o1, Human o2) {
        return o1.getName().compareTo(o2.getName());
    }
}

因此 Comparator 的实现方式更具扩展性和灵活性。建议使用。