当你想要比较两个对象时，首先想到的是定义一个比较器，比较器中规定了这两个对象的比较规则，当你需要对某个集合进行排序时，只需要将这个比较器传给排序程序里就行了。可以这么说，比较器就是对比较规则的封装。
Comparator就是一个比较器的封装类，所以他放在java.util包中，int compare(T o1, T o2);方法是比较器的核心方法，该方法实现具体的比较规则。
但是在日常比较中，除了使用比较器比较外，某些对象应该拥有默认的比较规则，这些规则是大家熟知的。就像我对你说我比你大，大家都知道说的是年龄，就像我们常说的这只狗比较大，比较的也是尺寸。这种默认的比较规则是不需要比较器去定义的，只要同一类的对象都知道就行了。
API把这种比较称作自然比较。实现Comparable的类，为此类的所有对象提供了自然或者默认的比较规则实现。对这些类进行排序或者比较时，就不需要比较器了。
Comparable-默认规则实现
public class Person implements Comparable<Person>{
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说的是职级而并不是年龄，这时候用代码怎么表示呢?
- 改代码咯，原来是比较年龄的，现在改成比较职级。这样是不合适的，假如等会又要按年龄比较，是不是还要改代码？或者说
Person类是别人jar包中的类，我没有源码怎么改。 - 继承
Person类，覆盖compareTo()方法，这种方法可行，但是不够灵活，不好扩展，父子类之间耦合性太强。比如说两种比较规则要组合在一起使用时。 - 既然继承没有优势，那用组合总行吧，组合拥有更强的灵活性和可扩展性。所以比较器出现了，上面的
Person实现了Comparable接口，只是规定了默认的比较规则，有没规定比较时必须使用这个规则。我用比较器定义一个我自己的规则就行了。
public static void main(String[] args) {
Person person1 = new Person("Messi",35,2);
Person person2 = new Person("Kobe",31,4);
Comparator<Person> comparator = new Comparator<Person>() {
@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<Person> 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<Person> comparator = new Comparator<Person>() {
@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<Person> 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<Person> 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<Person> byNameIgnoreCase = Comparator.comparing(Person::getName,Comparator.comparing(String::toLowerCase));
//效果同上
//Comparator<Person> 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<Person> 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<Person> byNature = Comparator.naturalOrder();
personList.sort(byNature);
personList.stream().map(Person::getName).forEach(System.out::println);
Toma
TOmb
Kobe
Messi
集合中存在null的情况
将null放在前面
Comparator<Person> 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<Person> 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<Person> byPositionReverse = Comparator.comparingInt(Person::getPosition).reversed();
personList.sort(byPositionReverse);
personList.stream().map(Person::getName).forEach(System.out::println);
Kobe
Messi
Toma
TOmb
自然排序的倒序。
Comparator<Person> byNatureReverse = Comparator.reverseOrder();
personList.sort(byNatureReverse);
personList.stream().map(Person::getName).forEach(System.out::println);
Messi
Kobe
Toma
TOmb
复合构造
解决这种需求，主字段排序和辅字段排序问题，比如两个Person对象比较，如果年龄相同则比较他们的职级。
Comparator<Person> complexComparator =Comparator.comparingInt(Person::getAge).thenComparing(Comparator.comparingInt(Person::getPosition));
//Comparator<Person> 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。
