本文深入探讨如何利用Java 11 Stream API对自定义对象流进行高效处理。核心在于解决一次性消费流的限制，通过将对象按指定属性（如`category`）进行分组计数，然后根据计数结果和属性值本身进行多级排序，最终生成一个有序的属性列表。文章提供了详细的代码示例和实现解析，旨在帮助开发者掌握复杂的Stream数据转换技巧。
引言：Stream数据转换的挑战
在Java应用开发中，我们经常需要对数据集合进行复杂的转换和聚合操作。Java Stream API自Java 8引入以来，极大地简化了这些任务。然而，当面临特定挑战时，例如在一个只能被消费一次的Stream上执行多阶段的数据处理，就需要精心设计Stream管道。本文将聚焦于一个常见场景：给定一个包含category属性的自定义对象流，我们需要生成一个按以下规则排序的类别列表：首先根据每个类别的出现频率进行排序（频率高的在前），如果频率相同，则按类别名称的字母顺序排序。
核心问题与解决方案
我们的目标是，在不重复消费原始Stream的前提下，实现一个既能统计类别频率，又能进行多级排序的解决方案。
问题定义：
立即学习“Java免费学习笔记（深入）”；
假设我们有一个MyType类的对象流，其中MyType定义如下：
public class MyType {
private String category;
public MyType(String category) {
this.category = category;
}
public String getCategory() {
return category;
}
// 其他属性、构造函数、getter/setter等...
}给定一个Stream<MyType>，我们需要返回一个List<String>，其中包含所有唯一的类别，并按照以下规则排序：
- 主排序规则： 类别出现的次数（频率）降序排列。
- 次排序规则： 如果两个类别的出现次数相同，则按类别名称的字母顺序升序排列。
解决方案概述：
解决此问题的关键在于分两步走：
- 分组与计数： 首先，利用Collectors.groupingBy和Collectors.counting将原始Stream转换为一个Map<String, Long>，其中键是类别名称，值是该类别出现的次数。这一步仅需一次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<String> getSortedCategories(Stream<MyType> stream) {
// 1. 分组并计数：将Stream<MyType>转换为Map<String, Long>
// 键是类别名称，值是该类别的出现次数。
Map<String, Long> 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.<String, Long>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<MyType> 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<MyType> myTypeStream = inputData.stream();
// 调用方法获取排序后的类别列表
List<String> 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<MyType>转换成一个Map<String, Long>。
- 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<Map.Entry<String, Long>>。
-
.sorted(Map.Entry.<String, Long>comparingByValue().reversed().thenComparing(Map.Entry.comparingByKey()))
- 这是实现多级排序的核心。
- Map.Entry.<String, Long>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 < B) 排在categoryB之前。
因此，最终输出的列表将是：
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进行复杂的数据聚合、多级排序等操作，从而更高效地处理各种数据转换需求。
