Comparator比较器在实际项目中的应用案例

Comparator比较器在实际项目中有广泛的应用，主要用于定义对象的排序规则。以下是一些常见的使用场景和示例：

1. 对象排序

Comparator常用于对集合中的对象进行排序。例如，对一个包含Person对象的列表按照年龄进行排序：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Person {
    String name;
    int age;

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("John", 30));
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 20));

        Collections.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return Integer.compare(p1.age, p2.age);
            }
        });

        System.out.println(people);
    }
}

2. 优先队列

Comparator也常用于优先队列（PriorityQueue）中，以定义元素的优先级顺序：

import java.util.PriorityQueue;

public class Main {
    public static void main(String[] args) {
        PriorityQueue<Person> queue = new PriorityQueue<>(new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return Integer.compare(p1.age, p2.age);
            }
        });

        queue.add(new Person("John", 30));
        queue.add(new Person("Alice", 25));
        queue.add(new Person("Bob", 20));

        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
    }
}

3. 匿名内部类和Lambda表达式

在Java 8之前，实现Comparator通常需要创建一个匿名内部类。Java 8引入了Lambda表达式，使得实现Comparator变得更加简洁：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("John", 30));
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 20));

        Collections.sort(people, (p1, p2) -> Integer.compare(p1.age, p2.age));

        System.out.println(people);
    }
}

4. 复杂对象的排序

对于包含多个字段或属性的复杂对象，可以通过实现Comparator接口或提供定制的比较器对象来定义对象之间的比较规则：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class UserInfo {
    String name;
    int age;

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

    @Override
    public String toString() {
        return "UserInfo{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        List<UserInfo> userInfos = new ArrayList<>();
        userInfos.add(new UserInfo("张三", 20));
        userInfos.add(new UserInfo("李四", 18));
        userInfos.add(new UserInfo("王五", 35));

        Collections.sort(userInfos, new Comparator<UserInfo>() {
            @Override
            public int compare(UserInfo o1, UserInfo o2) {
                return Integer.compare(o1.age, o2.age);
            }
        });

        System.out.println(userInfos);
    }
}

5. 使用Java 8的实用方法

Java 8还引入了一些静态方法，允许我们链式调用Comparator，实现更复杂的排序逻辑：

import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("John", 30));
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 20));

        List<Person> sortedPeople = people.stream()
                .sorted(Comparator.comparing(Person::getAge).thenComparing(Person::getName, Comparator.reverseOrder()))
                .collect(Collectors.toList());

        System.out.println(sortedPeople);
    }
}