Java基础系列-Comparable和Comparator

原创文章，转载请标注出处：[《java基础系列-comparable和comparator》](https://www.jianshu.com/p/f9870fd05958## 一、概述
        java中的排序是由comparable和comparator这两个接口来提供的。

        comparable表示可被排序的，实现该接口的类的对象自动拥有排序功能。

        comparator则表示一个比较器，实现了该接口的的类的对象是一个针对目标类的对象定义的比较器，一般情况，这个比较器将作为一个参数进行传递。

二、comparable

        comparable的中文意思就是可被排序的，代表本身支持排序功能。只要我们的类实现了这个接口，那么这个类的对象就会自动拥有了可被排序的能力。而且这个排序被称为类的自然顺序。这个类的对象的列表可以被collections.sort和arrays.sort来执行排序。同时这个类的实例具备作为sorted map的key和sorted set的元素的资格。

        假如a和b都是实现了comparable接口的类c的实例，那么只有当a.compareto(b)的结果与a.equals(b)的结果一致时，才称类c的自然顺序与equals一致。强烈建议将类的自然顺序和equals的结果保持一致，因为如果不一致的话，由该类对象为键的sorted map和由该类对象为元素的sorted set的行为将会变得很怪异。

        例如对于一个实现了comparable接口的元素的有序集合sorted set而言，如果a.equals(b)结果为false，并且a.compareto(b)==0，则第二个元素的添加操作将会失败，因为在sorted set看来，二者在排序上是一致的，它不报保存重复的元素。

        事实上，java中的类基本都是自然顺序与equals一致的，除了bigdecimal，因为bigdecimal中的自然顺序和值相同但精度不同的元素（例如4和4.00）的equals均一致。

源码解析

public interface comparable<t> {
    public int compareto(t o);
}

        从源码中可以看到，该接口只有一个抽象方法compareto，这个方法主要就是为了定义我们的类所要排序的方式。compareto方法用于比较当前元素a与指定元素b，结果为int值，如果a > b，int>0；如果a=b，int=0；如果a<b，int<0。

三、comparator

        comparator中文译为比较器，它可以作为一个参数传递到collections.sort和arrays.sort方法来指定某个类对象的排序方式。同时它也能为sorted set和sorted map指定排序方式。

        同comparable类似，指定比较器的时候一般也要保证比较的结果与equals结果一致，不一致的话，对应的sorted set和sorted map的行为同样会变得怪异。

        推荐实现的比较器类同时实现java.io.serializable接口，以拥有序列化能力，因为它可能会被用作序列化的数据结构（treeset、treemap）的排序方法。

源码解析

@functionalinterface
public interface comparator<t> {
    // 唯一的抽象方法，用于定义比较方式（即排序方式）
    // o1>o2，返回1；o1=o2，返回0；o1<o2，返回-1
    int compare(t o1, t o2);
    boolean equals(object obj);
    // 1.8新增的默认方法：用于反序排列
    default comparator<t> reversed() {
        return collections.reverseorder(this);
    }
    // 1.8新增的默认方法：用于构建一个次级比较器，当前比较器比较结果为0，则使用次级比较器比较
    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);
        };
    }
    // 1.8新增默认方法：指定次级比较器的
    // keyextractor表示键提取器，定义提取方式
    // keycomparator表示键比较器，定义比较方式
    default <u> comparator<t> thencomparing(
            function<? super t, ? extends u> keyextractor,
            comparator<? super u> keycomparator)
    {
        return thencomparing(comparing(keyextractor, keycomparator));
    }
    // 1.8新增默认方法：用于执行键的比较，采用的是由键对象内置的比较方式
    default <u extends comparable<? super u>> comparator<t> thencomparing(
            function<? super t, ? extends u> keyextractor)
    {
        return thencomparing(comparing(keyextractor));
    }
    // 1.8新增默认方法：用于比较执行int类型的键的比较
    default comparator<t> thencomparingint(tointfunction<? super t> keyextractor) {
        return thencomparing(comparingint(keyextractor));
    }
    // 1.8新增默认方法：用于比较执行long类型的键的比较
    default comparator<t> thencomparinglong(tolongfunction<? super t> keyextractor) {
        return thencomparing(comparinglong(keyextractor));
    }
    // 1.8新增默认方法：用于比较执行double类型的键的比较
    default comparator<t> thencomparingdouble(todoublefunction<? super t> keyextractor) {
        return thencomparing(comparingdouble(keyextractor));
    }
    // 1.8新增静态方法：用于得到一个相反的排序的比较器，这里针对的是内置的排序方式（即继承comparable）
    public static <t extends comparable<? super t>> comparator<t> reverseorder() {
        return collections.reverseorder();
    }
    // 1.8新增静态方法：用于得到一个实现了comparable接口的类的比较方式的比较器
    // 简言之就是将comparable定义的比较方式使用comparator实现
    @suppresswarnings("unchecked")
    public static <t extends comparable<? super t>> comparator<t> naturalorder() {
        return (comparator<t>) comparators.naturalordercomparator.instance;
    }
    // 1.8新增静态方法：得到一个null亲和的比较器，null小于非null，两个null相等，如果全不是null,
    // 则使用指定的比较器比较，若未指定比较器，则非null全部相等返回0
    public static <t> comparator<t> nullsfirst(comparator<? super t> comparator) {
        return new comparators.nullcomparator<>(true, comparator);
    }
    // 1.8新增静态方法：得到一个null亲和的比较器，null大于非null，两个null相等，如果全不是null,
    // 则使用指定的比较器比较，若未指定比较器，则非null全部相等返回0
    public static <t> comparator<t> nullslast(comparator<? super t> comparator) {
        return new comparators.nullcomparator<>(false, comparator);
    }
    // 1.8新增静态方法：使用指定的键比较器用于执行键的比较
    public static <t, u> comparator<t> comparing(
            function<? super t, ? extends u> keyextractor,
            comparator<? super u> keycomparator)
    {
        objects.requirenonnull(keyextractor);
        objects.requirenonnull(keycomparator);
        return (comparator<t> & serializable)
            (c1, c2) -> keycomparator.compare(keyextractor.apply(c1),
                                              keyextractor.apply(c2));
    }
    // 1.8新增静态方法：执行键比较，采用内置比较方式，key的类必须实现comparable
    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));
    }
    // 1.8新增静态方法：用于int类型键的比较
    public static <t> comparator<t> comparingint(tointfunction<? super t> keyextractor) {
        objects.requirenonnull(keyextractor);
        return (comparator<t> & serializable)
            (c1, c2) -> integer.compare(keyextractor.applyasint(c1), keyextractor.applyasint(c2));
    }
    // 1.8新增静态方法：用于long类型键的比较
    public static <t> comparator<t> comparinglong(tolongfunction<? super t> keyextractor) {
        objects.requirenonnull(keyextractor);
        return (comparator<t> & serializable)
            (c1, c2) -> long.compare(keyextractor.applyaslong(c1), keyextractor.applyaslong(c2));
    }
    // 1.8新增静态方法：用于double类型键的比较
    public static<t> comparator<t> comparingdouble(todoublefunction<? super t> keyextractor) {
        objects.requirenonnull(keyextractor);
        return (comparator<t> & serializable)
            (c1, c2) -> double.compare(keyextractor.applyasdouble(c1), keyextractor.applyasdouble(c2));
    }
}

        老版本的comparator中只要两个方法，就是前两个方法，后面的所有默认方法均为1.8新增的方法，采用的是1.8新增的功能：接口可添加默认方法。即便拥有如此多方法，该接口还是函数式接口，compare用于定义比较方式。

四、二者比较

        comparable可以看做是内部比较器，comparator可以看做是外部比较器。

        一个类，可以通过实现comparable接口来自带有序性，也可以通过额外指定comparator来附加有序性。

        二者的作用其实是一致的，所以不要混用。

        我们看个例子吧：

        首先定义个模型：user

public class user implements serializable, comparable<user> {
    private static final long serialversionuid = 1l;
    private int age;
    private string name;
    public user (){}
    public user (int age, string name){
        this.age = age;
        this.name = name;
    }
    public int getage() {
        return age;
    }
    public void setage(int age) {
        this.age = age;
    }
    public string getname() {
        return name;
    }
    public void setname(string name) {
        this.name = name;
    }
    @override
    public int compareto(user o) {
        return this.age - o.age;
    }
    @override
    public string tostring() {
        return "[user={age=" + age + ",name=" + name + "}]";
    }
}

        在定义一个comparator实现类mycomparator

public class mycomparator implements comparator<user> {
    @override
    public int compare(user o1, user o2) {
        return o1.getname().charat(0)-o2.getname().charat(0);
    }
}

        最后是测试类：main

public class main {
    public static void main(string[] args) {
        user u1 = new user(12, "xiaohua");
        user u2 = new user(10, "abc");
        user u3 = new user(15,"ccc");
        user[] users = {u1,u2,u3};
        system.out.print("数组排序前：");
        printarray(users);
        system.out.println();
        arrays.sort(users);
        system.out.print("数组排序1后：");
        printarray(users);
        system.out.println();
        arrays.sort(users, new mycomparator());
        system.out.print("数组排序2后：");
        printarray(users);
        system.out.println();
        arrays.sort(users, comparator.reverseorder());// 针对内置的排序进行倒置
        system.out.print("数组排序3后：");
        printarray(users);
    }
    public static void printarray (user[] users) {
        for (user user:users) {
            system.out.print(user.tostring());
        }
    }
}

        运行结果为：

数组排序前：[user={age=12,name=xiaohua}][user={age=10,name=abc}][user={age=15,name=ccc}]
数组排序1后：[user={age=10,name=abc}][user={age=12,name=xiaohua}][user={age=15,name=ccc}]
数组排序2后：[user={age=10,name=abc}][user={age=15,name=ccc}][user={age=12,name=xiaohua}]
数组排序3后：[user={age=15,name=ccc}][user={age=12,name=xiaohua}][user={age=10,name=abc}]

        通过上面的例子我们有一个结论，那就是两种方式定义排序的优先级，明显comparator比较器要优先于内部排序comparable。

五、总结

• comparable为可排序的，实现该接口的类的对象自动拥有可排序功能。
• comparator为比较器，实现该接口可以定义一个针对某个类的排序方式。
• comparator与comparable同时存在的情况下，前者优先级高。