JAVA8如何对list分组和排序

JAVA 8 提供了强大的流 (Stream) API，可以让我们轻松地对 List 进行分组和排序。主要的方法包括：使用 Collectors.groupingBy 进行分组、使用 sorted 方法进行排序、结合 Comparator 进行自定义排序。

以下是具体的实现方法和详细说明：

一、使用 Collectors.groupingBy 进行分组

在 Java 8 中，分组操作可以通过 Collectors.groupingBy 方法来实现。Collectors.groupingBy 接受一个分类函数，并返回一个 Map，其中键是分类函数的结果，值是与该键对应的元素列表。

例子

import java.util.*;
import java.util.stream.Collectors;
public class Main {
    public static void main(String[] args) {
        List<String> items = Arrays.asList("apple", "banana", "orange", "apple", "orange", "banana", "orange");
        Map<String, Long> result = items.stream()
                .collect(Collectors.groupingBy(e -> e, Collectors.counting()));
        System.out.println(result);
    }
}

在这个例子中，我们将字符串列表分组，并统计每个字符串出现的次数。

二、使用 Comparator 进行排序

排序操作可以通过 Stream API 中的 sorted 方法来实现。sorted 方法接受一个 Comparator 接口的实现，用于指定排序规则。

例子

import java.util.*;
import java.util.stream.Collectors;
public class Main {
    public static void main(String[] args) {
        List<String> items = Arrays.asList("apple", "banana", "orange", "apple", "orange", "banana", "orange");
        List<String> sortedItems = items.stream()
                .sorted()
                .collect(Collectors.toList());
        System.out.println(sortedItems);
    }
}

在这个例子中，我们将字符串列表按字典顺序排序。

三、自定义排序规则

有时候，我们需要按照特定的规则进行排序，例如按字符串长度排序。我们可以通过提供一个自定义的 Comparator 实现来完成这项任务。

例子

import java.util.*;
import java.util.stream.Collectors;
public class Main {
    public static void main(String[] args) {
        List<String> items = Arrays.asList("apple", "banana", "orange", "apple", "orange", "banana", "orange");
        List<String> sortedItems = items.stream()
                .sorted(Comparator.comparingInt(String::length))
                .collect(Collectors.toList());
        System.out.println(sortedItems);
    }
}

在这个例子中，我们将字符串列表按字符串长度进行排序。

四、分组和排序结合使用

有时候，我们需要先对列表进行分组，然后对每个组内的元素进行排序。我们可以通过嵌套使用 Collectors.groupingBy 和 sorted 方法来实现这一点。

例子

import java.util.*;
import java.util.stream.Collectors;
public class Main {
    public static void main(String[] args) {
        List<String> items = Arrays.asList("apple", "banana", "orange", "apple", "orange", "banana", "orange");
        Map<String, List<String>> groupedAndSortedItems = items.stream()
                .collect(Collectors.groupingBy(e -> e))
                .entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        e -> e.getValue().stream().sorted().collect(Collectors.toList()),
                        (e1, e2) -> e1, LinkedHashMap::new));
        System.out.println(groupedAndSortedItems);
    }
}

在这个例子中，我们首先将字符串列表按照字符串本身进行分组，然后对每个组内的元素进行排序，并最终将结果存储在一个有序的 LinkedHashMap 中。

五、实际应用中的复杂操作

在实际应用中，我们可能需要对包含复杂对象的列表进行分组和排序。例如，我们有一个包含用户对象的列表，我们需要按年龄分组，并在每个组内按用户的名字排序。

例子

import java.util.*;
import java.util.stream.Collectors;
class User {
    private String name;
    private int age;
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + '}';
    }
}
public class Main {
    public static void main(String[] args) {
        List<User> users = Arrays.asList(
                new User("John", 30),
                new User("Alice", 25),
                new User("Bob", 30),
                new User("Charlie", 25),
                new User("David", 35)
        );
        Map<Integer, List<User>> groupedAndSortedUsers = users.stream()
                .collect(Collectors.groupingBy(User::getAge))
                .entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        e -> e.getValue().stream().sorted(Comparator.comparing(User::getName)).collect(Collectors.toList()),
                        (e1, e2) -> e1, LinkedHashMap::new));
        groupedAndSortedUsers.forEach((age, userList) -> {
            System.out.println("Age: " + age);
            userList.forEach(System.out::println);
        });
    }
}

在这个例子中，我们首先将用户对象列表按年龄分组，然后对每个组内的用户对象按名字进行排序，并最终将结果存储在一个有序的 LinkedHashMap 中。

六、总结

通过 Java 8 提供的 Stream API 和 Collectors 工具类，我们可以非常灵活地对列表进行分组和排序。无论是简单的字符串列表，还是包含复杂对象的列表，我们都可以通过组合使用这些工具类来实现我们的需求。掌握这些技巧，不仅可以提高我们的编程效率，还可以让我们的代码更加简洁、易读。