17370845950

新闻动态

Java Stream：高效分组、计数与多级排序实践

本文深入探讨如何利用Java 11 Stream API对自定义对象流进行高效处理。核心在于解决一次性消费流的限制，通过将对象按指定属性（如`category`）进行分组计数，然后根据计数结果和属性值本身进行多级排序，最终生成一个有序的属性列表。文章提供了详细的代码示例和实现解析，旨在帮助开发者掌握复杂的Stream数据转换技巧。

引言：Stream数据转换的挑战

在Java应用开发中，我们经常需要对数据集合进行复杂的转换和聚合操作。Java Stream API自Java 8引入以来，极大地简化了这些任务。然而，当面临特定挑战时，例如在一个只能被消费一次的Stream上执行多阶段的数据处理，就需要精心设计Stream管道。本文将聚焦于一个常见场景：给定一个包含category属性的自定义对象流，我们需要生成一个按以下规则排序的类别列表：首先根据每个类别的出现频率进行排序（频率高的在前），如果频率相同，则按类别名称的字母顺序排序。

核心问题与解决方案

我们的目标是，在不重复消费原始Stream的前提下，实现一个既能统计类别频率，又能进行多级排序的解决方案。

问题定义：

假设我们有一个MyType类的对象流，其中MyType定义如下：

public class MyType {
    private String category;

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

    public String getCategory() {
        return category;
    }

    // 其他属性、构造函数、getter/setter等...
}

给定一个Stream，我们需要返回一个List，其中包含所有唯一的类别，并按照以下规则排序：

主排序规则： 类别出现的次数（频率）降序排列。
次排序规则： 如果两个类别的出现次数相同，则按类别名称的字母顺序升序排列。

解决方案概述：

解决此问题的关键在于分两步走：

分组与计数： 首先，利用Collectors.groupingBy和Collectors.counting将原始Stream转换为一个Map，其中键是类别名称，值是该类别出现的次数。这一步仅需一次Stream消费。
排序与提取： 接着，我们将这个Map的entrySet()转换为一个新的Stream，并对这个Stream进行排序。排序时，我们利用Map.Entry.comparingByValue()进行主排序（按计数），然后使用thenComparing(Map.Entry.comparingByKey())进行次排序（按类别名称）。最后，通过map操作提取排序后的类别名称，并收集到列表中。

实现细节与代码示例

下面是具体的Java 11实现代码：

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 + "'}";
        }
    }

    /**
     * 根据类别出现频率和类别名称对Stream中的类别进行排序。
     *
     * @param stream 包含MyType对象的Stream，只能消费一次。
     * @return 排序后的类别名称列表。
     */
    public static List getSortedCategories(Stream stream) {
        // 1. 分组并计数：将Stream转换为Map
        //    键是类别名称，值是该类别的出现次数。
        Map categoryCounts = stream.collect(
            Collectors.groupingBy(
                MyType::getCategory, // 按MyType对象的category属性分组
                Collectors.counting() // 统计每个分组中的元素数量
            )
        );

        // 2. 对Map的Entry进行排序并提取类别名称
        return categoryCounts.entrySet().stream() // 将Map的Entry集合转换为Stream
            .sorted(
                // 主排序：按值（计数）降序排列
                // 注意：comparingByValue()默认是升序，这里需要反转
                Map.Entry.comparingByValue().reversed()
                // 次排序：如果值（计数）相同，则按键（类别名称）升序排列
                .thenComparing(Map.Entry.comparingByKey())
            )
            .map(Map.Entry::getKey) // 提取排序后的Entry的键（即类别名称）
            .toList(); // 将结果收集到List中 (Java 16+ 或使用Collectors.toList() for Java 11)
    }

    public static void main(String[] args) {
        // 示例输入
        List inputData = List.of(
            new MyType("category1"),
            new MyType("categoryB"),
            new MyType("categoryA"),
            new MyType("category1"),
            new MyType("categoryB"),
            new MyType("category1"),
            new MyType("categoryA")
        );

        // 创建一个Stream，注意Stream只能消费一次
        Stream myTypeStream = inputData.stream();

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

        // 打印结果
        System.out.println("原始数据类别列表 (未排序):");
        inputData.stream().map(MyType::getCategory).forEach(System.out::println);
        System.out.println("\n排序后的类别列表:");
        System.out.println(sortedCategories); // 预期输出: [category1, categoryA, categoryB]
    }
}

代码解析：

stream.collect(Collectors.groupingBy(MyType::getCategory, Collectors.counting()))
- 这是整个解决方案的第一步，也是最关键的一步。它将原始Stream转换成一个Map。
- Collectors.groupingBy(MyType::getCategory)：这是一个下游收集器，它根据MyType对象的category属性对元素进行分组。所有具有相同category值的对象会被分到同一个组。
- Collectors.counting()：这是groupingBy的第二个参数，作为每个分组的“下游”收集器。它会统计每个分组中的元素数量，即每个类别的出现频率。
- 这一步完成后，我们得到了一个包含每个类别及其出现次数的映射，例如{category1=3, categoryB=2, categoryA=2}。
categoryCounts.entrySet().stream()
- 我们现在需要对上一步生成的Map的键值对（Map.Entry）进行排序。entrySet()方法返回Map中所有键值对的Set视图，我们可以将其转换为一个Stream>。
.sorted(Map.Entry.comparingByValue().reversed().thenComparing(Map.Entry.comparingByKey()))
- 这是实现多级排序的核心。
- Map.Entry.comparingByValue()：这是一个静态方法，返回一个Comparator，用于按Map.Entry的值（即类别计数Long）进行自然顺序（升序）比较。
- .reversed()：因为我们需要按计数降序排列（频率高的在前），所以我们调用reversed()来反转比较器的顺序。
- .thenComparing(Map.Entry.comparingByKey())：这是一个链式比较器。当主比较器（按计数）认为两个Entry相等时（即它们的计数相同），thenComparing会使用提供的次比较器（按键，即类别名称String）进行比较。comparingByKey()默认是按键的自然顺序（字母顺序）升序排列，这正是我们所需要的。
.map(Map.Entry::getKey)
- 排序完成后，我们不再需要Map.Entry的整个结构，只需要其中的键（类别名称）。map操作将每个Map.Entry转换为其对应的String类型的键。
.toList()
- 这是Java 16及更高版本中Stream接口的一个便捷方法，用于将Stream中的所有元素收集到一个新的List中。如果使用Java 11，需要替换为Collectors.toList()。

运行示例与结果

对于以下输入数据：

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

各类别出现频率如下：

category1: 3次
categoryA: 2次
categoryB: 2次

根据排序规则：

category1频率最高（3次），排第一。
categoryA和categoryB频率相同（2次）。
根据字母顺序，categoryA (A

因此，最终输出的列表将是：

List = {category1, categoryA, categoryB}

这与我们的代码运行结果一致。

注意事项与总结

Stream的一次性消费： 始终牢记Stream是单次消费的。一旦调用了终端操作（如collect、forEach、toList等），该Stream就不能再被使用。本教程中的方法通过将原始Stream首先转换为一个中间数据结构（Map），然后对这个中间结构进行Stream操作，巧妙地规避了这一限制。
Java版本兼容性： 示例中使用了Stream.toList()，这是Java 16引入的。对于Java 11等早期版本，应使用collect(Collectors.toList())。
性能考量： 这种方法在处理大量数据时是高效的。groupingBy和counting操作通常在O(N)时间复杂度内完成（N为Stream中的元素数量），而对Map Entry的排序则取决于Map中唯一类别的数量M，通常为O(M log M)。
可读性与维护性： Java Stream API提供了一种声明式编程风格，使得代码意图清晰，易于理解和维护。通过链式调用，可以将复杂的数据转换逻辑表达得简洁而富有表现力。

通过本文的学习，您应该能够熟练运用Java Stream API进行复杂的数据聚合、多级排序等操作，从而更高效地处理各种数据转换需求。

17370845950

引言：Stream数据转换的挑战

核心问题与解决方案

实现细节与代码示例

运行示例与结果

注意事项与总结

关于我们

服务项目

广告推广

案例欣赏