Java Stream：基于聚合计数进行分组与排序的高效实践_技术教程

本文详细介绍了如何利用java stream api，在仅允许一次流消费的前提下，对自定义对象流中的字符串属性进行分组、计数，并根据计数结果进行降序排序，对于计数相同的项再按字母顺序升序排序，最终生成一个有序的字符串列表。文章通过具体代码示例，演示了`collectors.groupingby`、`collectors.counting`以及自定义`comparator`的组合应用，提供了一种高效且符合函数式编程范式的解决方案。

Java Stream：基于聚合计数进行分组与排序

在处理数据流时，我们经常会遇到需要对数据进行分组、统计，并根据统计结果进行排序的场景。特别是在Java Stream API中，如果一个流只能被消费一次，这就要求我们设计一个单一的、连贯的操作链来完成所有任务。本教程将深入探讨如何高效地实现这一目标，即从一个自定义对象流中提取特定属性，根据其出现频率进行排序，并在频率相同的情况下进行二次排序。

1. 问题背景与挑战

假设我们有一个Stream，其中MyType是一个自定义类，包含一个String类型的category属性：

public class MyType {
    private String category;
    // 其他属性、构造函数、getter/setter等

    public MyType(String category) {
        this.category = category;
    }

    public String getCategory() {
        return category;
    }

    @Override
    public String toString() {
        return "MyType{category='" + category + "'}";
    }
}

我们的目标是生成一个List，包含所有唯一的category值，并按照以下规则进行排序：

主排序规则：根据每个category出现的次数（频率）进行降序排序。
次排序规则：如果两个category的出现次数相同，则按其字母顺序（字典序）进行升序排序。

核心挑战在于，我们只能对输入的Stream进行一次消费。

例如，给定以下输入：

{
    object1 :{category:"category1"},
    object2 :{category:"categoryB"},
    object3 :{category:"categoryA"},
    object4 :{category:"category1"},
    object5 :{category:"categoryB"},
    object6 :{category:"category1"},
    object7 :{category:"categoryA"}
}

期望的输出是：

List = {category1, categoryA, categoryB}

(因为category1出现3次，categoryA出现2次，categoryB出现2次。category1频率最高，categoryA和categoryB频率相同，但categoryA在字母顺序上先于categoryB。)

2. 解决方案：Stream API的组合应用

解决这个问题的关键在于两个步骤：

分组与计数：首先，我们需要遍历流，将所有MyType对象按其category属性进行分组，并计算每个category出现的总次数。这将生成一个Map，其中键是category名称，值是其出现频率。
流化、排序与提取：接下来，我们将这个Map的entrySet()转换为一个新的流。然后，对这个流中的Map.Entry对象进行自定义排序，最后提取出排序后的category名称并收集到一个列表中。

2.1 详细实现

以下是实现上述逻辑的Java方法：

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CategorySorter {

    // MyType 类定义（如上所示）
    public static class MyType {
        private String category;

        public MyType(String category) {
            this.category = category;
        }

        public String getCategory() {
            return category;
        }

        @Override
        public String toString() {
            return "MyType{category='" + category + "'}";
        }
    }

    /**
     * 根据类别出现频率（降序）和类别名称（升序）对类别进行排序。
     *
     * @param stream 包含MyType对象的流，只能消费一次。
     * @return 排序后的类别名称列表。
     */
    public static List getSortedCategories(Stream stream) {
        return stream
            // 步骤1: 分组并计数
            .collect(Collectors.groupingBy(
                MyType::getCategory, // 按MyType对象的category属性分组
                Collectors.counting() // 计算每个分组中的元素数量
            )) // 结果是一个 Map，例如: {"category1": 3, "categoryB": 2, "categoryA": 2}

            // 步骤2: 将Map的entrySet转换为流
            .entrySet().stream()

            // 步骤3: 对Map.Entry进行排序
            .sorted(
                // 主排序: 按值（计数）降序
                Map.Entry.comparingByValue().reversed()
                // 次排序: 如果值（计数）相同，则按键（类别名称）升序
                .thenComparing(Map.Entry.comparingByKey())
            )

            // 步骤4: 提取排序后的键（类别名称）
            .map(Map.Entry::getKey)

            // 步骤5: 收集结果到列表中 (Java 16+ 的简洁写法，Java 8-15 可用 .collect(Collectors.toList()))
            .toList(); 
    }

    public static void main(String[] args) {
        // 示例输入数据
        Stream inputData = Arrays.asList(
            new MyType("category1"),
            new MyType("categoryB"),
            new MyType("categoryA"),
            new MyType("category1"),
            new MyType("categoryB"),
            new MyType("category1"),
            new MyType("categoryA")
        ).stream();

        // 调用方法获取排序后的类别列表
        List sortedCategories = getSortedCategories(inputData);

        // 打印结果
        System.out.println("排序后的类别列表: " + sortedCategories); 
        // 预期输出: 排序后的类别列表: [category1, categoryA, categoryB]
    }
}

2.2 代码解析

stream.collect(Collectors.groupingBy(MyType::getCategory, Collectors.counting())):
- 这是整个解决方案的第一步，也是最关键的一步。它将原始的Stream转换为一个Map。
- Collectors.groupingBy(MyType::getCategory)：这是一个下行收集器，它根据MyType对象的getCategory()方法返回的字符串对元素进行分组。
- Collectors.counting()：这是groupingBy的第二个参数，作为下游收集器。它会计算每个分组中的元素数量，并将结果作为Map的值。
- 通过这一步，我们得到了每个类别的频率统计，并且只对原始流进行了一次消费。
.entrySet().stream():
- collect操作返回的是一个Map。为了对Map中的键值对进行排序，我们需要获取其entrySet()，并将其转换为一个新的Stream>。
.sorted(Map.Entry.comparingByValue().reversed().thenComparing(Map.Entry.comparingByKey())):
- 这是排序逻辑的核心。我们使用Map.Entry提供的静态方法来构建一个复合Comparator。
- Map.Entry.comparingByValue()：创建一个Comparator，根据Map.Entry的值（即类别计数Long）进行升序比较。
- .reversed()：紧接着comparingByValue()之后调用，将默认的升序比较反转为降序。这满足了我们“按频率降序”的主排序规则。
- .thenComparing(Map.Entry.comparingByKey())：如果前一个比较器（即按值降序）认为两个元素相等（即它们的计数相同），则使用这个次级比较器。它根据Map.Entry的键（即类别名称String）进行升序比较。这满足了我们“频率相同则按字母顺序升序”的次排序规则。
.map(Map.Entry::getKey):
- 在排序完成后，我们不再需要Map.Entry的计数信息，只需要类别名称。map操作将每个Map.Entry对象转换为其对应的键（category字符串）。
.toList():
- 这是Java 16引入的一个便捷方法，用于将流中的所有元素收集到一个不可修改的List中。
- 如果使用Java 8到Java 15，则应使用collect(Collectors.toList())。

3. 注意事项与总结

单次流消费：本解决方案严格遵循了“流只能消费一次”的限制，通过一次collect操作将流转换为一个中间数据结构（Map），后续操作都是基于这个Map进行的。
可读性与效率：使用Stream API的链式操作使得代码意图清晰，可读性强。groupingBy和counting是高度优化的收集器，能够高效地完成分组计数任务。
Java版本兼容性：核心逻辑在Java 8及更高版本中均可使用。toList()方法是Java 16的特性，如果使用旧版本，请替换为collect(Collectors.toList())。
通用性：这种模式不仅适用于String类型的category，也可以扩展到其他可比较的类型，只需调整groupingBy的分类器和comparingByKey的类型即可。

通过以上方法，我们能够优雅且高效地解决在Java Stream中，对数据进行复杂分组、计数和多级排序的问题，即使在面对单次流消费的约束时也能游刃有余。