Comparator是Java.util 包中的一个接口，用于比较两个对象的大小关系。通过实现该接口的compare()方法，可以自定义比较规则。
Comparator接口的两种使用方式：
一、以匿名内部类的方式使用
对象本身不支持比较或者已经有默认的比较规则，但是需要根据其他条件进行排序时，可以使用Comparator进行定制化排序。
举个例子，如果有一个UserInfo类，它包含userName和age两个属性，想按照年龄从小到大排序，则可以编写如下代码：
List<UserInfo> userInfos = new ArrayList<>();
// 使用Collections工具类添加对象
Collections.addAll(userInfos, new UserInfo("1",20,(byte)0,"张三" ),
new UserInfo("2",18,(byte)0,"李四"),
new UserInfo("3",35,(byte)0,"王五"));
// 可以从大到小，也可以从小到大
Collections.sort(userInfos, new Comparator<UserInfo>() {
@Override
public int compare(UserInfo o1, UserInfo o2) {
// 按照年龄从大到小排序
return o2.getAge() - o1.getAge();
}
});
System.out.println("排序后的集合：" + userInfos);
运行结果：
排序后的集合：[UserInfo [userUid=3, age=35, sex=0, userName=王五], UserInfo [userUid=1, age=20, sex=0, userName=张三], UserInfo [userUid=2, age=18, sex=0, userName=李四]]
二、以实现 Comparable 接口的方式使用
如果想对某个类进行比较并排序，可以让该类实现Comparable接口，重写compareTo()方法，然后调用Collections.sort()或Arrays.sort()方法进行排序，也可以使用Comparator进行排序。
例如，有一个Student类，它包含id和name两个属性，我们想按照id从小到大排序，则可以编写如下代码：
/**
* 实现Comparable接口
* @author 程就人生
* @Date
*/
class Student implements Comparable<Student> {
private int id;
private String name;
@Override
public int compareTo(Student o) {
// 按照id从小到大排序
return this.id - o.getId();
}
public Student(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + "]";
}
}
在使用Comparator时，需要注意compare()方法的返回值。如果返回正整数，则表示o1大于o2；如果返回负整数，则表示o1小于o2；如果返回0，则表示o1等于o2。
List<Student> students = new ArrayList<>();
// 使用Collections工具类添加对象
Collections.addAll(students, new Student(3,"张三" ),
new Student(1,"李四"),
new Student(4,"王五"));
// 调用Collections.sort()方法进行排序
Collections.sort(students);
System.out.println("排序后的集合：" + students);
// 或者使用Comparator进行排序
Collections.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 按照id从小到大排序
return o2.getId() - o1.getId();
}
});
System.out.println("再次排序后的集合：" + students);
运行结果：
排序后的集合：[Student [id=1, name=李四], Student [id=3, name=张三], Student [id=4, name=王五]]
再次排序后的集合：[Student [id=4, name=王五], Student [id=3, name=张三], Student [id=1, name=李四]]
Comparator接口的其他静态方法的使用：
1、comparing()方法：根据对象属性对对象进行排序。
// 更简便的排序写法
userInfos.stream()
// 进行排序，按照age升序
//.sorted(Comparator.comparing(UserInfo::getAge))
.sorted(Comparator.comparing(item->item.getAge()))
.forEach(item->System.out.println(item.toString()));
运行结果：
UserInfo [userUid=2, age=18, sex=0, userName=李四]
UserInfo [userUid=1, age=20, sex=0, userName=张三]
UserInfo [userUid=3, age=35, sex=0, userName=王五]
2、reverseOrder()方法：返回与当前比较器相反的比较器。
假设有一个包含整数的列表，我们可以按照从大到小的顺序对其进行排序。
首先，我们需要实现一个比较器：
Comparator<Integer> descendingOrder = Comparator.reverseOrder();
然后，我们可以使用这个比较器来对列表进行排序：
List<Integer> numbers = Arrays.asList(5, 3, 9, 1, 6);
Collections.sort(numbers, descendingOrder);
System.out.println(numbers);
运行结果：
[9, 6, 5, 3, 1]
最后的运行结果，表示元素已按照从大到小的顺序排序。
完整代码：
Comparator<Integer> descendingOrder = Comparator.reverseOrder();
List<Integer> numbers = Arrays.asList(5, 3, 9, 1, 6);
Collections.sort(numbers, descendingOrder);
System.out.println(numbers);
在上面的示例中，我们创建了一个名为descendingOrder的比较器，该比较器将按照降序排序元素。我们通过调用静态方法reverseOrder()来创建一个反转当前比较器的比较器，并将其赋值给descendingOrder。然后，我们使用Collections.sort()方法对整数列表进行排序，并将descendingOrder作为比较器传递。
3、naturalOrder()方法：返回一个使用自然顺序进行排序的比较器。
这个比较器要求待比较的对象实现Comparable接口。
假设有一个字符串列表，我们想按照字母表顺序对其进行排序。
首先，我们需要实现一个比较器：
Comparator<String> naturalOrder = Comparator.naturalOrder();
然后，可以使用这个比较器进行比较来对列表进行排序。
List<String> words = Arrays.asList("banana", "apple", "orange", "pear");
Collections.sort(words, naturalOrder);
System.out.println(words);
运行结果：
[apple, banana, orange, pear]
最后的运行结果，表示元素已按照字母表顺序排序。
在上面的示例中，我们创建了一个名为naturalOrder的比较器，该比较器将按照自然顺序排序元素。我们通过调用静态方法naturalOrder()来创建一个使用自然顺序进行排序的比较器，并将其赋值给naturalOrder。然后，我们使用Collections.sort()方法对字符串列表进行排序，并将naturalOrder作为比较器传递。
4、nullsFirst()方法：返回一个null安全的比较器，将null视为小于非空元素。
比较器首先比较null，如果两个元素均不为null，则使用传入的比较器进行比较。
假设有一个包含字符串的列表，其中一些元素为null。我们想按照字母表顺序对其进行排序，并将null视为小于非空元素。
首先，我们需要实现一个自然顺序比较器和一个null元素优先的比较器：
Comparator<String> naturalOrder = Comparator.naturalOrder();
Comparator<String> nullsFirstOrder = Comparator.nullsFirst(naturalOrder);
然后，我们可以使用这2个比较器来对列表进行排序：
List<String> words = Arrays.asList("banana", "", "apple", null, "orange", "pear", null);
Collections.sort(words, nullsFirstOrder);
System.out.println(words);
运行结果：
[null, null, , apple, banana, orange, pear]
最后的运行结果表示，元素已按照字母表顺序排序，并将null排在开头。
nullsLast()方法刚好相反，把null排在最后，在此不再举例。
5、thenComparing()方法是用于在原有比较器的基础上进行二次排序的。
如果原有比较器比较的两个对象相等，那么再对这两个对象使用传入的参数进行比较。
以下是thenComparing()方法的基本用法：
Comparator<T> comparator = firstComparator.thenComparing(secondComparator);
其中，firstComparator和secondComparator都是实现了Comparator<T>接口的比较器。上面的代码会创建一个新的比较器comparator，该比较器首先使用firstComparator进行排序，如果两个元素相等，则使用secondComparator进行排序。
以下是一个示例，展示如何使用thenComparing()方法对多个字段进行排序：
假设有一个包含UserInfo对象的列表，UserInfo类包含userName和age属性。我们想按照年龄从小到大排序，如果年龄相同，则按照名字字典序排序。
我们可以按照以下步骤编写比较器：
首先，使用Comparator.comparing()方法创建一个比较器来按照年龄进行排序。
Comparator<UserInfo> ageComparator = Comparator.comparing(UserInfo::getAge);
然后，使用Comparator.comparing()方法创建一个比较器来按照名字字典序进行排序。
Comparator<UserInfo> nameComparator = Comparator.comparing(UserInfo::getUserName);
接下来，使用thenComparing()方法将两个比较器组合成一个新的比较器。
Comparator<UserInfo> ageThenNameComparator = ageComparator.thenComparing(nameComparator);
最后，使用Collections.sort()方法按照新的比较器对Person对象列表进行排序。
Collections.sort(userInfos, ageThenNameComparator);
运行结果：
[UserInfo [userUid=2, age=18, sex=0, userName=李四], UserInfo [userUid=1, age=20, sex=0, userName=张三], UserInfo [userUid=3, age=35, sex=0, userName=王五]]
完整代码：
Comparator<UserInfo> ageComparator = Comparator.comparing(UserInfo::getAge);
Comparator<UserInfo> nameComparator = Comparator.comparing(UserInfo::getUserName);
Comparator<UserInfo> ageThenNameComparator = ageComparator.thenComparing(nameComparator);
Collections.sort(userInfos, ageThenNameComparator);
System.out.println(userInfos);
以上便是本次的整理，希望对你有帮助。
