Java Stream 高效分组、排序与转换：构建有序字符串集合

本文深入探讨了如何利用 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> 形式：

[3] -> ["Select Item", "Pay money", "Deliver"]
[1] -> ["Create PO", "Generate Invoice", "Generate Payment"]
[2] -> ["Select Item", "Pay money", "Deliver"]

需要完成的操作包括：

1. 按 orderId 分组。
2. 按 timestamp 对每个组内的 action 进行排序。
3. 将排序后的 action 收集到一个 Set 中，以去除重复项并保持排序顺序。

初始尝试与挑战

一个常见的误区是尝试在 groupingBy 的下游收集器中直接使用 TreeSet 并提供一个基于 timestamp 的比较器。例如：

// 尝试一：无法得到 Map>
// orderRows.stream()
//     .collect(Collectors.groupingBy(OrderRow::getOrderId,
//         Collectors.mapping(Function.identity(),
//             Collectors.toCollection(
//                 () -> new TreeSet<>(Comparator.comparing(OrderRow::getTimestamp))
//     ))));

这种方法会产生 Map>，而不是我们期望的 Map>。更重要的是，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 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> 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，它允许我们在下游收集器完成收集后，对结果进行最终的转换。

Codiga

可自定义的静态代码分析检测工具

下载

方法二点一：使用 TreeSet 进行排序

我们可以先将 OrderRow 对象收集到 TreeSet 中进行排序，然后再将其转换为 action 字符串的 LinkedHashSet。

// ... (OrderRow 和 orderRows 数据同上)

        Map> 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 映射为 action 字符串，最后收集到 LinkedHashSet 中。LinkedHashSet 再次用于保持从 TreeSet 继承的排序顺序，并处理重复项。

性能考量： TreeSet 内部使用红黑树实现，每次插入操作的时间复杂度为 O(log N)。对于大量的元素，维护红黑树的开销可能比其他排序算法更高。

方法二点二：使用 List 和 Timsort 进行排序

Java 8 Stream.sorted() 和 List.sort() 方法底层都使用了 Timsort 算法，它通常在实际数据中表现出 O(N log N) 的平均时间复杂度，并且在许多情况下比红黑树的维护更快。

// ... (OrderRow 和 orderRows 数据同上)

        Map> 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> 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 提供了强大的工具。选择哪种方法取决于具体的性能要求、数据量大小以及代码可读性偏好。

1. LinkedHashSet 的重要性： 无论采用哪种排序策略，最终将 action 收集到 LinkedHashSet 是至关重要的。它能够确保在去除重复元素的同时，严格保持元素被添加到集合时的顺序。如果使用 HashSet，顺序将无法保证；如果使用 TreeSet，它将按字符串的自然顺序（字母顺序）排序，而不是我们期望的基于 timestamp 的顺序。
2. 排序策略与性能：
   • 预先排序整个流 (stream.sorted().collect(...))：代码最简洁，但如果分组键较少且数据量大，全局排序的开销可能很高。
   • TreeSet 内部排序 (collectingAndThen + TreeSet)：在分组内部实现了排序，但红黑树的维护成本可能高于 Timsort。
   • List + Timsort 内部排序 (collectingAndThen + List + stream.sorted())：利用 Timsort 的高效性，但 stream.sorted() 会创建中间数组。
   • List + 原地 sort() 内部排序 (collectingAndThen + List + list.sort())：这是在 groupingBy 内部实现排序的最优化方案，因为它利用了 Timsort 并避免了不必要的中间对象创建。
3. 可读性与复杂性： 随着 collectingAndThen 嵌套层级的增加，代码的可读性可能会略有下降。在性能要求不极致的情况下，简单的预先排序方案可能更受欢迎。

通过理解这些不同的策略和它们背后的机制，开发者可以根据具体需求，灵活选择最适合的 Java Stream 解决方案来高效处理数据。