Java比较器的使用背景：

Java中的对象，正常情况下，只能进行比较：== 或 != 。不能使用 > 或 < 的但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。如何实现？使用两个接口中的任何一个：Comparable 或 Comparator

自然排序 : 使用`Comparable` 接口

像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式
重写compareTo(obj)的规则：
1. 如果当前对象this大于形参对象obj，则返回正整数
2. 如果当前对象this小于形参对象obj，则返回负整数
3. 如果当前对象this等于形参对象obj，则返回零。
对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法。在compareTo(obj)方法中指明如何排序

自定义排序,代买举例 :

/**
    指明商品比较大小的方式:照价格从低到高排序,再照产品名称从高到低排序
*/
class Goods implements Comparable {
    private String name;
    private double price;
    @Override
    public int compareTo(Object o) {
        if (o instanceof Goods) {
            Goods goods = (Goods) o;
            //方式一：
            if (this.price > goods.price) {
                return 1;
            } else if (this.price < goods.price) {
                return -1;
            } else {
//                return 0;
                return -this.name.compareTo(goods.name);
            }
            //方式二：
//           return Double.compare(this.price,goods.price);
        }
//        return 0;
        throw new RuntimeException("传入的数据类型不一致！");
    }
// getter、setter、toString()、构造器：省略
}

定制排序：使用`Comparator`接口

当元素的类型没实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序
重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
1. 如果方法返回正整数，则表示o1大于o2
2. 如果返回0，表示相等
3. 返回负整数，表示o1小于o2。

定制排序 , 代码举例 :

/**
 例1:
    指明商品比较大小的方式:照产品名称从低到高排序,再照价格从高到低排序
 */
Comparator com = new Comparator() {
    @Override
    public int compare(Object o1, Object o2) {
        if(o1 instanceof Goods && o2 instanceof Goods){
            Goods g1 = (Goods)o1;
            Goods g2 = (Goods)o2;
            if(g1.getName().equals(g2.getName())){
                return -Double.compare(g1.getPrice(),g2.getPrice());
            }else{
                return g1.getName().compareTo(g2.getName());
            }
        }
        throw new RuntimeException("输入的数据类型不一致");
    }
}
/**
 例2:
    将集合中的元素从大到小排序
 */
@Test
public void hashTest() {
    String[] arr = {"AA", "BB", "CC", "DD"};
    //从大到小排序
    Arrays.sort(arr, new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            String s1 = (String) o1;
            String s2 = (String) o2;
            if (o1 instanceof String && o2 instanceof String) {
                return -s1.compareTo(s2);
            }
            return 0;
        }
    });
}

两种排序方式对比

Comparable接口的方式一旦一定，保证Comparable接口实现类的对象在任何位置都可以比较大小。
Comparator接口属于临时性的比较。

原文： https://howtodoinjava.com/java/collections/java-comparator/

Java 比较器接口，用于根据自定义顺序对对象的数组或列表进行排序。通过在对象中实现Comparator.compare()方法来强加元素的自定义顺序。

1. Java `Comparator`接口

Java Comparator接口在可能没有自然顺序的对象上强加了自定义顺序。

例如，对于Elpmoyees对象的列表，自然顺序可以是按员工 ID 排序的顺序。但是在现实生活中，我们可能希望按照员工的名字，出生日期或其他任何类似标准对员工列表进行排序。在这种情况下，我们需要使用Comparator接口。

在以下情况下，我们可以使用Comparator接口。

对对象的数组或列表进行排序，但不按自然顺序排序。
在无法修改对象源代码以实现[Comparable](https://howtodoinjava.com/java/collections/java-comparable-interface/)接口的情况下，对对象的数组或列表进行排序。
在不同字段上对相同对象列表或对象数组进行排序。
在不同字段上对对象列表或数组进行分组排序。

1.1. `Comparator.compare()`

为了对对象启用总体排序，我们需要创建实现Comparator接口的类。然后，我们需要覆盖它的compare(T o1, T o2)方法。

它比较两个参数的顺序。当第一个参数小于，等于或大于第二个参数时，它将返回负整数，零或正整数。

实现者还必须确保该关系是可传递的：compare(x, y)>0 && compare(y, z)>0隐含compare(x, z)>0。

import java.time.LocalDate;
public class Employee implements Serializable {
    private static final long serialVersionUID = 1L;
    private Long id;
    private String name;
    private LocalDate dob;
    //Getters and Setters
    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", dob=" + dob + "]";
    }
}

对于以上类别，可以通过创建如下的Comparator来强行按员工姓名排序。

import java.util.Comparator;

public class NameSorter implements Comparator<Employee>
{
    @Override
    public int compare(Employee e1, Employee e2) {
        return e1.getName().compareToIgnoreCase( e2.getName() );
    }
}

1.2 `Collections.sort()`和`Arrays.sort()`

使用Collections.sort(list, Comparator)方法按提供的比较器实例施加的顺序对对象的列表进行排序。
使用Arrays.sort(array, Comparator)方法按提供的比较器实例施加的顺序对对象的数组进行排序。

1.3 `Collections.comparing()`

该工具方法接受一个为类提取排序键的函数。本质上，这是一个将对类对象进行排序的字段。

//Order by name
Comparator.comparing(Employee::getName);

//Order by name in reverse order
Comparator.comparing(Employee::getName).reversed();

//Order by id field
Comparator.comparing(Employee::getId);

//Order by employee age
Comparator.comparing(Employee::getDate);

1.4 `Collections.thenComparing()`

该工具方法按类别分组。使用此方法，我们可以链接多个比较器以对多个字段上的对象列表或对象数组进行排序。

它与SQL GROUP BY子句非常相似，可以对不同字段上的行进行排序。

//Order by name and then by age
Comparator.comparing(Employee::getName)
            .thenComparing(Employee::getDob);

//Order by name -> date of birth -> id 
Comparator.comparing(Employee::getName)
            .thenComparing(Employee::getDob)
            .thenComparing(Employee::getId);

使用以上语法，我们几乎可以创建任何排序逻辑。

1.5 `Collections.reverseOrder()`

此工具方法返回一个比较器，该比较器在实现Comparable接口的对象集合上强加自然排序或自定义排序的逆向。

//Reverse of natural order as specified in 
//Comparable interface's compareTo() method 

Comparator.reversed();

//Reverse of order by name

Comparator.comparing(Employee::getName).reversed();

2. Java `Comparator`示例

2.1 排序对象列表

Java 示例使用比较器按名称对员工列表进行排序。

ArrayList<Employee> list = new ArrayList<>();

list.add(new Employee(22l, "Lokesh", LocalDate.now()));
list.add(new Employee(30l, "Bob", LocalDate.now()));
list.add(new Employee(18l, "Alex", LocalDate.now()));
list.add(new Employee(5l, "David", LocalDate.now()));
list.add(new Employee(600l, "Charles", LocalDate.now()));

//Sort in reverse natural order
Collections.sort(list, new NameSorter());

System.out.println(list);

程序输出。

[
    Employee [id=18, name=Alex, dob=2018-10-30], 
    Employee [id=30, name=Bob, dob=2018-10-30], 
    Employee [id=600, name=Charles, dob=2018-10-30], 
    Employee [id=5, name=David, dob=2018-10-30], 
    Employee [id=22, name=Lokesh, dob=2018-10-30]
]

2.2 以相反的顺序对对象列表进行排序

Java 示例使用反向顺序使用比较器按名称对员工列表进行排序。

ArrayList<Employee> list = new ArrayList<>();

list.add(new Employee(22l, "Lokesh", LocalDate.now()));
list.add(new Employee(30l, "Bob", LocalDate.now()));
list.add(new Employee(18l, "Alex", LocalDate.now()));
list.add(new Employee(5l, "David", LocalDate.now()));
list.add(new Employee(600l, "Charles", LocalDate.now()));

Collections.sort(list, Comparator.comparing( Employee::getName ).reversed());

System.out.println(list);

程序输出：

[
    Employee [id=22, name=Lokesh, dob=2018-10-30], 
    Employee [id=5, name=David, dob=2018-10-30], 
    Employee [id=600, name=Charles, dob=2018-10-30], 
    Employee [id=30, name=Bob, dob=2018-10-30], 
    Employee [id=18, name=Alex, dob=2018-10-30]
]

2.3 通过按照多个字段对对象列表进行分组排序

Java 示例，用于按多个字段对多个字段（即字段）上的雇员列表进行排序。

ArrayList<Employee> list = new ArrayList<>();

list.add(new Employee(22l, "Lokesh", LocalDate.now()));
list.add(new Employee(30l, "Lokesh", LocalDate.now()));
list.add(new Employee(18l, "Alex", LocalDate.now()));
list.add(new Employee(5l, "Lokesh", LocalDate.now()));
list.add(new Employee(600l, "Charles", LocalDate.now()));

Comparator<Employee> groupByComparator = Comparator.comparing(Employee::getName)
                                        .thenComparing(Employee::getDob)
                                        .thenComparing(Employee::getId);

Collections.sort(list, groupByComparator);

System.out.println(list);

程序输出：

[
    Employee [id=18, name=Alex, dob=2018-10-30], 
    Employee [id=600, name=Charles, dob=2018-10-30], 
    Employee [id=5, name=Lokesh, dob=2018-10-30], 
    Employee [id=22, name=Lokesh, dob=2018-10-30], 
    Employee [id=30, name=Lokesh, dob=2018-10-30]]

3. 总结

在本教程中，我们学习了 Java 集合框架的Comparator接口。它有助于在不更改该类源代码的情况下，对对象施加总体顺序。

我们学会了对对象的列表和数组进行排序。我们学习了如何使用Comparator接口在 Java 中对员工对象进行排序，即 Java 比较器的多个字段示例。

将我的问题放在评论部分。

学习愉快！

参考文献：

[Comparator](https://docs.oracle.com/javase/8/docs/api/java/lang/Comparator.html)接口 Java 文档

Comparator

Java比较器的使用背景：

自然排序 : 使用Comparable 接口

定制排序：使用Comparator接口

两种排序方式对比

1. Java Comparator接口

1.1. Comparator.compare()

1.2 Collections.sort()和Arrays.sort()

1.3 Collections.comparing()

1.4 Collections.thenComparing()

1.5 Collections.reverseOrder()

2. Java Comparator示例