本文深入探讨了如何利用 Java Stream API 高效地对数据进行分组、排序和转换。通过结合 `Collectors.groupingBy`、`Collectors.mapping` 和 `Collectors.collectingAndThen`，并巧妙运用 `LinkedHashSet` 和不同的排序策略（如 `Timsort`），我们将学习如何将原始数据集合转换为按指定顺序排列的、无重复的字符串集合，特别关注在处理大数据集时的性能优化。
在现代Java应用开发中，数据处理是核心任务之一。Java Stream API 提供了一种强大而声明式的方式来处理集合数据。本教程将聚焦于一个常见但具有挑战性的场景：给定一个包含订单详情的列表，我们需要根据订单ID对其进行分组，然后根据时间戳对每个组内的操作进行排序，并最终提取出按时间顺序排列的、不重复的操作名称集合。
场景描述与数据模型
假设我们有一个 OrderRow 类，它代表了订单中的一个具体操作：
import java.time.LocalDateTime;
public class OrderRow {
private Long orderId;
private String action;
private LocalDateTime timestamp;
public OrderRow(Long orderId, String action, LocalDateTime timestamp) {
this.orderId = orderId;
this.action = action;
this.timestamp = timestamp;
}
// Getters
public Long getOrderId() {
return orderId;
}
public String getAction() {
return action;
}
public LocalDateTime getTimestamp() {
return timestamp;
}
@Override
public String toString() {
return "OrderRow{" +
"orderId=" + orderId +
", action='" + action + '\'' +
", timestamp=" + timestamp +
'}';
}
}我们有一组 OrderRow 数据，例如：
立即学习“Java免费学习笔记（深入）”；
OrderId Action Timestamp 3 Pay money 2015-05-27 12:48:47.000 3 Select Item 2015-05-27 12:44:47.000 1 Generate Payment 2015-05-27 12:55:47.000 2 Pay money 2015-05-27 12:48:47.000 2 Select Item 2015-05-27 12:44:47.000 2 Deliver 2015-05-27 12:55:47.000 1 Generate Invoice 2015-05-27 12:48:47.000 1 Create PO 2015-05-27 12:44:47.000 3 Deliver 2015-05-27 12:55:47.000
我们的目标是将其转换为以下 Map<Long, Set<String>> 形式：
[3] -> ["Select Item", "Pay money", "Deliver"] [1] -> ["Create PO", "Generate Invoice", "Generate Payment"] [2] -> ["Select Item", "Pay money", "Deliver"]
需要完成的操作包括：
- 按 orderId 分组。
- 按 timestamp 对每个组内的 action 进行排序。
- 将排序后的 action 收集到一个 Set 中，以去除重复项并保持排序顺序。
初始尝试与挑战
一个常见的误区是尝试在 groupingBy 的下游收集器中直接使用 TreeSet 并提供一个基于 timestamp 的比较器。例如：
// 尝试一：无法得到 Map<Long, Set<String>> // orderRows.stream() // .collect(Collectors.groupingBy(OrderRow::getOrderId, // Collectors.mapping(Function.identity(), // Collectors.toCollection( // () -> new TreeSet<>(Comparator.comparing(OrderRow::getTimestamp)) // ))));
这种方法会产生 Map<Long, Set<OrderRow>>，而不是我们期望的 Map<Long, Set<String>>。更重要的是，TreeSet 虽然能保证元素有序，但其排序是基于元素本身的比较器。一旦我们将 OrderRow 映射为 String (即 action)，TreeSet 将无法根据原始 OrderRow 的 timestamp 进行排序，因为它只知道 String。我们需要一个能够保留插入顺序的 Set 实现，同时确保插入的顺序是经过 timestamp 排序后的结果。
为了解决这个问题，我们需要更精细地控制 groupingBy 下游收集器的行为，特别是如何进行排序和最终的转换。
解决方案一：预先对整个流进行排序
最直接的方法是在 groupingBy 之前，先对整个 OrderRow 流进行排序。这样，当 groupingBy 处理元素时，它们已经按照 timestamp 的全局顺序排列。
import java.util.*;
import java.util.stream.Collectors;
public class StreamGroupingAndSorting {
public static void main(String[] args) {
List<OrderRow> orderRows = Arrays.asList(
new OrderRow(3L, "Pay money", LocalDateTime.parse("2015-05-27T12:48:47")),
new OrderRow(3L, "Select Item", LocalDateTime.parse("2015-05-27T12:44:47")),
new OrderRow(1L, "Generate Payment", LocalDateTime.parse("2015-05-27T12:55:47")),
new OrderRow(2L, "Pay money", LocalDateTime.parse("2015-05-27T12:48:47")),
new OrderRow(2L, "Select Item", LocalDateTime.parse("2015-05-27T12:44:47")),
new OrderRow(2L, "Deliver", LocalDateTime.parse("2015-05-27T12:55:47")),
new OrderRow(1L, "Generate Invoice", LocalDateTime.parse("2015-05-27T12:48:47")),
new OrderRow(1L, "Create PO", LocalDateTime.parse("2015-05-27T12:44:47")),
new OrderRow(3L, "Deliver", LocalDateTime.parse("2015-05-27T12:55:47"))
);
Map<Long, Set<String>> actionsById = orderRows.stream()
// 1. 预先对整个流进行排序
.sorted(Comparator.comparing(OrderRow::getTimestamp))
// 2. 按 orderId 分组
.collect(Collectors.groupingBy(
OrderRow::getOrderId,
// 3. 将 OrderRow 映射为 action，并收集到 LinkedHashSet 以保持插入顺序
Collectors.mapping(
OrderRow::getAction,
Collectors.toCollection(LinkedHashSet::new)
)
));
System.out.println("Solution 1 (Pre-sorting): " + actionsById);
// 预期输出:
// {1=[Create PO, Generate Invoice, Generate Payment], 2=[Select Item, Pay money, Deliver], 3=[Select Item, Pay money, Deliver]}
}
}解析：
- sorted(Comparator.comparing(OrderRow::getTimestamp)): 在分组之前，对整个 OrderRow 流根据 timestamp 进行排序。这确保了相同 orderId 的元素在进入 groupingBy 收集器时，已经按照时间戳的顺序排列。
- Collectors.mapping(OrderRow::getAction, Collectors.toCollection(LinkedHashSet::new)): 这是 groupingBy 的下游收集器。它首先将每个 OrderRow 映射为其 action 字符串，然后将这些 action 收集到一个 LinkedHashSet 中。LinkedHashSet 的关键特性是它能保持元素的插入顺序，并且不包含重复元素。由于上游流已经排序，所以 LinkedHashSet 将按照时间戳的顺序接收并存储 action。
优点： 代码简洁，易于理解。 缺点： 如果数据集非常大，对整个流进行排序可能会消耗大量内存和CPU资源，尤其是在 groupingBy 键的数量相对较少时。
解决方案二：在 groupingBy 内部进行排序和转换（使用 collectingAndThen）
为了避免对整个流进行排序，我们可以在 groupingBy 内部，针对每个分组的数据进行独立的排序和转换。这需要使用 Collectors.collectingAndThen，它允许我们在下游收集器完成收集后，对结果进行最终的转换。
方法二点一：使用 TreeSet 进行排序
我们可以先将 OrderRow 对象收集到 TreeSet 中进行排序，然后再将其转换为 action 字符串的 LinkedHashSet。
// ... (OrderRow 和 orderRows 数据同上)
Map<Long, Set<String>> actionsByIdTreeSet = orderRows.stream()
.collect(Collectors.groupingBy(
OrderRow::getOrderId,
Collectors.collectingAndThen(
// 1. 将 OrderRow 收集到 TreeSet，根据 timestamp 排序
Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(OrderRow::getTimestamp))),
// 2. 对 TreeSet 的结果进行后处理：映射为 action 并收集到 LinkedHashSet
set -> set.stream()
.map(OrderRow::getAction)
.collect(Collectors.toCollection(LinkedHashSet::new))
)
));
System.out.println("Solution 2.1 (TreeSet within groupingBy): " + actionsByIdTreeSet);解析：
- Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(OrderRow::getTimestamp))): 对于每个 orderId 分组，首先将 OrderRow 对象收集到一个 TreeSet 中。这个 TreeSet 使用 OrderRow::getTimestamp 作为比较器，因此 OrderRow 对象在 TreeSet 中是按时间戳排序的。
- set -> set.stream().map(OrderRow::getAction).collect(Collectors.toCollection(LinkedHashSet::new)): 这是 collectingAndThen 的“finisher”函数。它接收排序好的 TreeSet<OrderRow>，然后将其流化，将每个 OrderRow 映射为 action 字符串，最后收集到 LinkedHashSet 中。LinkedHashSet 再次用于保持从 TreeSet 继承的排序顺序，并处理重复项。
性能考量： TreeSet 内部使用红黑树实现，每次插入操作的时间复杂度为 O(log N)。对于大量的元素，维护红黑树的开销可能比其他排序算法更高。
方法二点二：使用 List 和 Timsort 进行排序
Java 8 Stream.sorted() 和 List.sort() 方法底层都使用了 Timsort 算法，它通常在实际数据中表现出 O(N log N) 的平均时间复杂度，并且在许多情况下比红黑树的维护更快。
// ... (OrderRow 和 orderRows 数据同上)
Map<Long, Set<String>> actionsByIdTimsort = orderRows.stream()
.collect(Collectors.groupingBy(
OrderRow::getOrderId,
Collectors.collectingAndThen(
// 1. 将 OrderRow 收集到 List
Collectors.mapping(
Function.identity(), Collectors.toList()
),
// 2. 对 List 进行后处理：排序、映射为 action 并收集到 LinkedHashSet
list -> list.stream()
.sorted(Comparator.comparing(OrderRow::getTimestamp)) // 使用 Timsort 排序
.map(OrderRow::getAction)
.collect(Collectors.toCollection(LinkedHashSet::new))
)
));
System.out.println("Solution 2.2 (Timsort within groupingBy): " + actionsByIdTimsort);解析：
- Collectors.mapping(Function.identity(), Collectors.toList()): 对于每个 orderId 分组，首先将 OrderRow 对象收集到一个普通的 List 中。
- list -> list.stream().sorted(Comparator.comparing(OrderRow::getTimestamp)).map(OrderRow::getAction).collect(Collectors.toCollection(LinkedHashSet::new)): 在 finisher 函数中，我们将 List 转换为一个新的流，然后使用 sorted() 方法根据 timestamp 进行排序（利用 Timsort）。之后，与之前一样，映射为 action 并收集到 LinkedHashSet。
性能考量： 相比 TreeSet，Timsort 在处理大数据量时通常具有更好的实际性能。然而，list.stream().sorted() 会创建一个新的中间数组来执行排序，这可能带来额外的内存开销。
解决方案三：优化 List 排序（原地排序）
为了进一步优化性能，我们可以避免在 finisher 函数中再次创建新的流并调用 sorted() 方法。相反，我们可以直接对收集到的 List 进行原地排序，然后将其流化并进行映射和收集。
import java.util.function.Function; // 确保导入 Function
// ... (OrderRow 和 orderRows 数据同上)
Map<Long, Set<String>> actionsByIdOptimized = orderRows.stream()
.collect(Collectors.groupingBy(
OrderRow::getOrderId,
Collectors.collectingAndThen(
// 1. 将 OrderRow 收集到 List
Collectors.mapping(
Function.identity(), Collectors.toList()
),
// 2. 对 List 进行原地排序，然后流化、映射为 action 并收集到 LinkedHashSet
list -> {
list.sort(Comparator.comparing(OrderRow::getTimestamp)); // 原地排序，避免创建新流
return list.stream()
.map(OrderRow::getAction)
.collect(Collectors.toCollection(LinkedHashSet::new));
}
)
));
System.out.println("Solution 3 (Optimized In-place List Sorting): " + actionsByIdOptimized);解析：
- list -> { list.sort(Comparator.comparing(OrderRow::getTimestamp)); ... }: 这是最关键的优化点。我们直接调用 List 对象的 sort() 方法进行原地排序。这避免了 list.stream().sorted() 可能引入的额外中间流和数组分配开销。
性能考量： 这是在 groupingBy 内部实现排序和转换的最高效方法之一，因为它充分利用了 Timsort 的优势，并减少了不必要的对象创建和流操作。对于性能敏感的场景，这种方法是首选。
总结与注意事项
在处理复杂的数据分组、排序和转换需求时，Java Stream API 提供了强大的工具。选择哪种方法取决于具体的性能要求、数据量大小以及代码可读性偏好。
- LinkedHashSet 的重要性： 无论采用哪种排序策略，最终将 action 收集到 LinkedHashSet 是至关重要的。它能够确保在去除重复元素的同时，严格保持元素被添加到集合时的顺序。如果使用 HashSet，顺序将无法保证；如果使用 TreeSet<String>，它将按字符串的自然顺序（字母顺序）排序，而不是我们期望的基于 timestamp 的顺序。
-
排序策略与性能：
- 预先排序整个流 (stream.sorted().collect(...))：代码最简洁，但如果分组键较少且数据量大，全局排序的开销可能很高。
- TreeSet 内部排序 (collectingAndThen + TreeSet)：在分组内部实现了排序，但红黑树的维护成本可能高于 Timsort。
- List + Timsort 内部排序 (collectingAndThen + List + stream.sorted())：利用 Timsort 的高效性，但 stream.sorted() 会创建中间数组。
- List + 原地 sort() 内部排序 (collectingAndThen + List + list.sort())：这是在 groupingBy 内部实现排序的最优化方案，因为它利用了 Timsort 并避免了不必要的中间对象创建。
- 可读性与复杂性： 随着 collectingAndThen 嵌套层级的增加，代码的可读性可能会略有下降。在性能要求不极致的情况下，简单的预先排序方案可能更受欢迎。
通过理解这些不同的策略和它们背后的机制，开发者可以根据具体需求，灵活选择最适合的 Java Stream 解决方案来高效处理数据。
