本文详细介绍了如何利用java stream api，在仅允许一次流消费的前提下，对自定义对象流中的字符串属性进行分组、计数，并根据计数结果进行降序排序，对于计数相同的项再按字母顺序升序排序，最终生成一个有序的字符串列表。文章通过具体代码示例，演示了`collectors.groupingby`、`collectors.counting`以及自定义`comparator`的组合应用，提供了一种高效且符合函数式编程范式的解决方案。
Java Stream：基于聚合计数进行分组与排序
在处理数据流时，我们经常会遇到需要对数据进行分组、统计，并根据统计结果进行排序的场景。特别是在Java Stream API中，如果一个流只能被消费一次，这就要求我们设计一个单一的、连贯的操作链来完成所有任务。本教程将深入探讨如何高效地实现这一目标，即从一个自定义对象流中提取特定属性，根据其出现频率进行排序，并在频率相同的情况下进行二次排序。
1. 问题背景与挑战
假设我们有一个Stream
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的出现次数相同，则按其字母顺序（字典序）进行升序排序。
核心挑战在于，我们只能对输入的Stream
立即学习“Java免费学习笔记（深入）”；
例如，给定以下输入：
{
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的值。
- 通过这一步，我们得到了每个类别的频率统计，并且只对原始流进行了一次消费。
- 这是整个解决方案的第一步，也是最关键的一步。它将原始的Stream
-
.entrySet().stream():
- collect操作返回的是一个Map。为了对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中，对数据进行复杂分组、计数和多级排序的问题，即使在面对单次流消费的约束时也能游刃有余。
