在Java中，Comparator 是一个函数式接口，可以使用 Lambda 表达式来实现。Lambda 表达式提供了一种简洁的方式来定义匿名的比较器，而无需显式实现 Comparator 接口。
以下是一些使用 Lambda 表达式编写 Comparator 的示例：

示例 1：按字符串长度比较

import java.util.Arrays;
import java.util.Comparator;

public class LambdaComparatorExample {
    public static void main(String[] args) {
        String[] words = {"apple", "banana", "cherry", "date"};

        // 使用 Lambda 表达式按字符串长度升序排序
        Arrays.sort(words, (s1, s2) -> s1.length() - s2.length());
		//等价于Arrays.sort(words, Comparator.comparing(String::length));
        System.out.println(Arrays.toString(words)); // 输出：[date, apple, banana, cherry]
    }
}

示例 2：按数字大小比较

import java.util.Arrays;
import java.util.Comparator;

public class LambdaComparatorExample {
    public static void main(String[] args) {
        Integer[] numbers = {5, 2, 9, 1, 5, 6};

        // 使用 Lambda 表达式按数字升序排序
        Arrays.sort(numbers, (n1, n2) -> n1.compareTo(n2));

        System.out.println(Arrays.toString(numbers)); // 输出：[1, 2, 5, 5, 6, 9]
    }
}

示例 3：按对象属性比较

假设有一个 Person 类，包含 name 和 age 属性：

import java.util.*;

class Person {
    String name;
    int age;

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

    @Override
    public String toString() {
        return name + ": " + age;
    }
}

public class LambdaComparatorExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 30),
                new Person("Bob", 25),
                new Person("Charlie", 35)
        );

        // 按年龄升序排序
        people.sort((p1, p2) -> p1.age - p2.age);

        // 按年龄降序排序
        people.sort((p1, p2) -> p2.age - p1.age);

        // 按姓名升序排序
        people.sort(Comparator.comparing(p -> p.name));

        System.out.println(people); // 输出：[Alice: 30, Bob: 25, Charlie: 35]
    }
}

（简洁：推荐）示例 4：使用 Comparator 的静态方法

Java 8 引入了 Comparator 的一些静态方法，可以更简洁地实现比较器：
Comparator实现逆序很简单，就是加一个 .reversed()就完事儿了

import java.util.*;

class Person {
    String name;
    int age;

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

    @Override
    public String toString() {
        return name + ": " + age;
    }
}

public class LambdaComparatorExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 30),
                new Person("Bob", 25),
                new Person("Charlie", 35)
        );

        // 按年龄升序排序
        people.sort(Comparator.comparing(Person::getAge));
		//效果一样people.sort(Comparator.comparing(p -> p.age));
        // 按年龄降序排序
        //people.sort(Comparator.comparingInt(p -> p.age).reversed());

        // 按姓名升序排序
        //people.sort(Comparator.comparing(p -> p.name));

        System.out.println(people); 
    }
}

示例 5：链式比较

如果需要按多个属性进行排序，可以使用 Comparator 的 thenComparing 方法：
可以链式调用继续 thenComparing(XXXClass::getXXX)就完事儿了，比如比较字符串长度就是 thenComparing(String::length)，比较其他就是 thenComparing(XXXClass::getXXX)

package AAA;

import java.util.*;
class Person {
    public String name;
    public int age;

    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 name + ": " + age;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
                new Person("Alice", 30),
                new Person("Bob", 25),
                new Person("Alice", 20)
        );
        people.sort(Comparator.comparing(Person::getAge).thenComparing(Person::getName));



        System.out.println(people); // 输出：[Alice: 20, Bob: 25, Alice: 30]
    }
}

总结
使用 Lambda 表达式编写 Comparator 可以让代码更加简洁和易读。通过结合 Comparator 的静态方法（如 comparing、comparingInt、reversed、thenComparing 等），可以实现复杂的排序逻辑，而无需手动实现 Comparator 接口。