java 中Comparable 和 Comparator 比较

首先你不要觉得俩个接口很神秘的样子，其实只是你还不会用而已。这俩个接口是Java源代码中定义的俩个接口来方便进行排序。你只要在类中实现了这俩个接口，就可以调用java中提供的一些工具类来进行排序，类如Collections.sort() ，Arrays.sort()方法。这些方法中已经默认只要你实现了这俩个接口，该类就可以调用这俩个接口中定义的方法来进行排序。

Comparable 简介

Comparable 是排序接口。
若一个类实现了Comparable接口，就意味着该类“支持排序”。既然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表或者数组”，则该List列表或数组可以通过Collection.sort（或Arrays.sort）进行排序
此外，“实现Comparable接口的类的独享可以用作有序映射中的键或有序集合中的元素”，而不需要指定比较器。

Comparable定义

Comparable 接口只包含一个函数，他的定义如下：

package java.lang;
import java.util.*;

public interface Comparable<T> {

   public int compareTo(T o);

}

假设我们通过x.compareTo(y)，来比较x和y的大小。若返回负数，意味着x比y小，返回零，意味着x等于y，返回正数，意味着x大于y。这就相当于帮我们把比较这段代码给写好，我们直接用就可以，只不过这段代码是要按照Java规定的格式来写。就是你要实现Comparable接口，接着其他类如果发现该类实现了Comparable接口，就知道该类是支持排序的，则使用comparaTo方法进行比较。

Comparator 简介

Comparator 是比较器接口。
我们若要控制某个类的次序，而该类不支持排序（即没有实现Comparable接口），那么，我们可以建立一个该类的比较器来进行排序。这个比较器需要实现Comparator接口。
简单的说，就是我们要单独定义一个类，此类实现了Comparator接口，该接口就是专门用来进行比较的。

Comparator 定义

Comparator 接口仅仅只包含俩个函数，定义如下

package java.util;

public interface Comparator<T> {

    int compare(T o1, T o2);

    boolean equals(Object obj);
}

说明：
1. 若一个类实现了Comparator接口，则一定要实现compare方法，可以不识闲equabls方法，因为Object默认实现了equals方法，而java中所有的类都是默认继承Object类，也就是每个类都会默认包含一个equals方法。
2. int compare（T o1,T o2）是比较o1和o2的大小，返回负数，意味着o1 比 o2小，返回0表示相等，返回整数，表示 o1 比 o2大。

Comparable 和Comparator比较

Comparable 是排序接口：若一个类实现了Comparable接口，就意味着该类支持排序。
Comparator 是比较器接口：也就是我们要控制某个类的次序，需要建立一个该类的比较器来进行排序。
通过对比可以发现，Comparable 接口是类内部实现的，相当于内部比较器，而Comparator是需要借助一个外部类来实现，相当于外部比较器。
下面是是个简单的源代码，来使用这俩个接口：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;


public class CompareComparatorAndComparable {

    public static void main(String[] args) {
        //新建ArrayList 动态数组
        ArrayList<Person> list = new ArrayList<>();

        // 添加对象到ArrayList中

        list.add(new Person("AAA", 30));
        list.add(new Person("ddd", 40));
        list.add(new Person("bbb", 10));
        list.add(new Person("ccc", 20));


        // 打印list的原始序列
        System.out.printf("Original  sort, list:%s\n", list);

        // 这里会根据“Person实现的Comparable<String>接口”进行排序，即会根据“name”进行排序
        Collections.sort(list);
        System.out.printf("Name      sort, list:%s\n", list);

        // 通过“比较器(AscAgeComparator)”，对list进行排序
        // AscAgeComparator的排序方式是：根据“age”的升序排序
        Collections.sort(list, new AscAgeComparator());
        System.out.printf("Asc(age)  sort, list:%s\n", list);

        // 通过“比较器(DescAgeComparator)”，对list进行排序
        Collections.sort(list, new DescAgeComparator());
        // DescAgeComparator的排序方式是：根据“age”的降序排序
        System.out.printf("Desc(age) sort, list:%s\n", list);

        // 判断两个person是否相等
        testEquals();

    }

    /**
     * 测试两个Person比较是否相等。
     * 由于Person实现了equals()函数：若两person的age、name都相等，则认为这两个person相等。
     * 所以，这里的p1和p2相等。
     * <p>
     * TODO：若去掉Person中的equals()函数，则p1不等于p2
     */
    private static void testEquals() {
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        if (p1.equals(p2)) {
            System.out.printf("%s EQUAL %s\n", p1, p2);
        } else {
            System.out.printf("%s NOT EQUAL %s\n", p1, p2);
        }
    }

    /**
     * 实现了comparable 接口，这意味着Person本身支持排序
     */
    private static class Person implements Comparable<Person> {
        int age;
        String name;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public int getAge() {
            return age;
        }

        public String getName() {
            return name;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }

        /**
         * 这里通过person的名字进行比较
         *
         * @param o
         * @return
         */
        @Override
        public int compareTo(Person o) {
            return name.compareTo(o.name);
        }

        /**
         * 比较俩个person是否相等:若他们name和age都相等，则默认他们相等
         *
         * @param o
         * @return
         */

        public boolean equals(Person o) {

            if (this.age == o.age && this.name == o.name)
                return true;
            return false;
        }

    }

    /**
     * person的age的升序比较器
     */
    private static class AscAgeComparator
            implements Comparator<Person> {

        @Override
        public int compare(Person o1, Person o2) {
            return o1.getAge() - o2.getAge();
        }
    }

    /**
     * person的age的降序比较器
     */
    private static class DescAgeComparator
            implements Comparator<Person> {

        @Override
        public int compare(Person o1, Person o2) {
            return o2.getAge() - o1.getAge();
        }
    }

}