Comparable和Comparator

当你想要比较两个对象时，首先想到的是定义一个比较器，比较器中规定了这两个对象的比较规则，当你需要对某个集合进行排序时，只需要将这个比较器传给排序程序里就行了。可以这么说，比较器就是对比较规则的封装。

Comparator就是一个比较器的封装类，所以他放在java.util包中，int compare(T o1, T o2);方法是比较器的核心方法，该方法实现具体的比较规则。

但是在日常比较中，除了使用比较器比较外，某些对象应该拥有默认的比较规则，这些规则是大家熟知的。就像我对你说我比你大，大家都知道说的是年龄，就像我们常说的这只狗比较大，比较的也是尺寸。这种默认的比较规则是不需要比较器去定义的，只要同一类的对象都知道就行了。API把这种比较称作自然比较。实现Comparable的类，为此类的所有对象提供了自然或者默认的比较规则实现。对这些类进行排序或者比较时，就不需要比较器了。

Comparable-默认规则实现

public class Person implements Comparable{

    private String name;
    private int age;
    //指的是职位
    private int position;

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

    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;
    }

    public int getPosition() {
        return position;
    }

    public void setPosition(int position) {
        this.position = position;
    }

    @Override
    public int compareTo(Person o) {
        return this.age > o.getAge() ? 1 : (this.age == o.getAge() ? 0 : -1);
    }
}

上面的Person实现了Comparable接口，规定每个Person对象在比较时默认比较的是年龄，比如：

public static void main(String[] args) {
    Person person1 = new Person("Messi",35,2);
    Person person2 = new Person("Kobe",31,4);
    if(person1.compareTo(person2) == 1) {
        System.out.println(person1.getName() + "要比" + person2.getName() + "大...");
    } else if(person1.compareTo(person2) == -1){
        System.out.println(person2.getName() + "要比" + person1.getName() + "大...");
    } else {
        System.out.println(person2.getName() + "和" + person1.getName() + "一样大...");
    }
}

Messi要比Kobe大...

Comparator-定制比较规则

但是有一天Kobe和Messi起了争执，Kobe是Messi的上司，Kobe对Messi说：“我比你大，你得听我的...”，上面的语境很明显能判断出Kobe说的是职级而并不是年龄，这时候用代码怎么表示呢?

1. 改代码咯，原来是比较年龄的，现在改成比较职级。这样是不合适的，假如等会又要按年龄比较，是不是还要改代码？或者说Person类是别人jar包中的类，我没有源码怎么改。
2. 继承Person类，覆盖compareTo()方法，这种方法可行，但是不够灵活，不好扩展，父子类之间耦合性太强。比如说两种比较规则要组合在一起使用时。
3. 既然继承没有优势，那用组合总行吧，组合拥有更强的灵活性和可扩展性。所以比较器出现了，上面的Person实现了Comparable接口，只是规定了默认的比较规则，有没规定比较时必须使用这个规则。我用比较器定义一个我自己的规则就行了。

public static void main(String[] args) {
    Person person1 = new Person("Messi",35,2);
    Person person2 = new Person("Kobe",31,4);
    Comparator comparator = new Comparator() {
        @Override
        public int compare(Person o1, Person o2) {
            return o1.getPosition() > o2.getPosition() ? 1 : (o1.getPosition() == o2.getPosition() ? 0 : -1);
        }
    };
    if(comparator.compare(person1,person2) == 1) {
        System.out.println(person1.getName() + "要比" + person2.getName() + "大...");
    } else if(comparator.compare(person1,person2) == -1){
        System.out.println(person2.getName() + "要比" + person1.getName() + "大...");
    } else {
        System.out.println(person2.getName() + "和" + person1.getName() + "一样大...");
    }
}

Kobe要比Messi大...

可以看到，有了比较器，我可以按照任何规则进行比较了，只需要第一号相应的规则就好。比较器在排序中也非常重要，某一天公司老板把所有的Person召集到一起训话，Kobe、Messi、Tom等到场后，老板说，你们按顺序坐在第一排，说完就去忙别的了，所有Person就按照默认的规则顺序的坐在前排，邓老板回来，连忙说，错了错了，我是说按职级的顺序坐。这就是在现实生活中按xxx排序的场景。在这样的场景中，Comparator起到了无可替代的作用。

Person person1 = new Person("Messi",35,2);
Person person2 = new Person("Kobe",31,4);
Person person3 = new Person("Tom",25,1);

List personList = new ArrayList<>(Arrays.asList(new Person[]{person1,person2,person3}));
//默认排序
Collections.sort(personList);
personList.stream().map(Person::getName).forEach(Systm.out::println);
/*
    Tom
    Kobe
    Messi
*/
//定制规则排序
Comparator comparator = new Comparator() {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getPosition() > o2.getPosition() ? 1 : (o1.getPosition() == o2.getPosition() ? 0 : -1);
    }
};
Collections.sort(personList,comparator);
//personList.sort(comparator);

personList.stream().map(Person::getName).forEach(Systm.out::println);
/*
    Tom
    Messi
    Kobe
*/

构造Comparator

看到上面出现的匿名类，我就浑身不舒服，每一个比较规则都要去构造一个比较器岂不是很麻烦么。放心，Comparator为我们提供了许多实用的构造方式。

按照对象内部一个可排序的key构造

对象内部某个key实现了Comparable接口，并且这个key的默认比较规则符合现实场景。

//按照name排序，name字段的类型必须实现Comparable接口
Comparator byName = Comparator.comparing(Person::getName);
personList.sort(byName);
personList.stream().map(Person::getName).forEach(System.out::println);

Kobe
Messi
TOmb
Toma

对象内部基本数据类型的比较

如果对象内部某个key是基本数据类型如int、long、double等。

Comparator byPosition = Comparator.comparingInt(Person::getPosition);
personList.sort(byPosition);
personList.stream().map(Person::getName).forEach(System.out::println);

Toma
TOmb
Messi
Kobe

按照对象内部一个key和给定的key比较器构造

如果对象内部某个key没有实现Comparable接口，或者这个key的默认比较规则仍不符合场景的情况。这种构造方式可以将key的比较策略一直挖掘下去，直到出现基本数据。

//按照名称排序，忽略大小写
Comparator byNameIgnoreCase = Comparator.comparing(Person::getName,Comparator.comparing(String::toLowerCase));
//效果同上
//Comparator byNameIgnoreCase = Comparator.comparing(Person::getName,String.CASE_INSENSITIVE_ORDER);
personList.sort(byNameIgnoreCase);
personList.stream().map(Person::getName).forEach(System.out::println);

Kobe
Messi
Toma
TOmb

//按名字长度排序
Comparator byNameLength = Comparator.comparing(Person::getName,Comparator.comparingInt(String::length));
personList.sort(byNameLength);
personList.stream().map(Person::getName).forEach(System.out::println);

Kobe
Toma
TOmb
Messi

按照自然排序规则构造

就是按照对象本身默认的规则构造一个比较器。

//自然（默认）排序规则
Comparator byNature = Comparator.naturalOrder();
personList.sort(byNature);
personList.stream().map(Person::getName).forEach(System.out::println);

Toma
TOmb
Kobe
Messi

集合中存在null的情况

将null放在前面

Comparator nullFirst = Comparator.nullsFirst(Comparator.naturalOrder());
personList.sort(nullFirst);
personList.stream().map(o -> o == null?"null":o.getName()).forEach(System.out::println);

null
Toma
TOmb
Kobe
Messi

将null放在后面

Comparator nullLast = Comparator.nullsLast(Comparator.naturalOrder());
personList.sort(nullLast);
personList.stream().map(o -> o == null?"null":o.getName()).forEach(System.out::println);

Toma
TOmb
Kobe
Messi
null

倒序排序

将已知的比较器反转。

//反转
Comparator byPositionReverse = Comparator.comparingInt(Person::getPosition).reversed();
personList.sort(byPositionReverse);
personList.stream().map(Person::getName).forEach(System.out::println);

Kobe
Messi
Toma
TOmb

自然排序的倒序。

Comparator byNatureReverse = Comparator.reverseOrder();
personList.sort(byNatureReverse);
personList.stream().map(Person::getName).forEach(System.out::println);

Messi
Kobe
Toma
TOmb

复合构造

解决这种需求，主字段排序和辅字段排序问题，比如两个Person对象比较，如果年龄相同则比较他们的职级。

Comparator complexComparator =Comparator.comparingInt(Person::getAge).thenComparing(Comparator.comparingInt(Person::getPosition));
//Comparator complexComparator = Comparator.comparingInt(Person::getAge).thenComparing(Person::getName,String.CASE_INSENSITIVE_ORDER);
personList.sort(complexComparator);
personList.stream().map(Person::getName).forEach(System.out::println);

总结

在谈到比较和排序时，首先想到的应该是Comparator而不是Comparable，Comparable是将对象和对象的比较行为耦合在一起，Comparator是将二者解耦。说到底一个是NatureOrder 一个 是 CustomOrder。