17370845950

1. 引言：数据分组的需求

在日常的java开发中，我们经常会遇到需要处理复杂数据结构的情况。其中一种常见场景是拥有一个list

示例数据结构：

假设我们有以下交易数据，存储在一个List

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Collection;
import java.util.stream.Collectors;

public class DataGroupingExample {

    public static void main(String[] args) {
        List> dataListMap = new ArrayList<>();

        // 交易1
        Map dataMap1 = new HashMap() {{
            put("Charged fare", "3");
            put("Trip ID", "1");
            put("Account", "220");
        }};
        dataListMap.add(dataMap1);

        // 交易2
        Map dataMap2 = new HashMap() {{
            put("Charged fare", "5");
            put("Trip ID", "2");
            put("Account", "220");
        }};
        dataListMap.add(dataMap2);

        // 交易3
        Map dataMap3 = new HashMap() {{
            put("Charged fare", "7");
            put("Trip ID", "3");
            put("Account", "230");
        }};
        dataListMap.add(dataMap3);

        // 交易4
        Map dataMap4 = new HashMap() {{
            put("Charged fare", "8");
            put("Trip ID", "4");
            put("Account", "230");
        }};
        dataListMap.add(dataMap4);

        System.out.println("原始数据列表:");
        dataListMap.forEach(System.out::println);
        System.out.println("\n---");

        // 接下来的分组和重组操作将基于此dataListMap
    }
}

我们的目标是根据"Account"键的值，将dataListMap中的元素分组，最终得到一个List>>，其中每个内部列表包含属于同一个账户的所有交易记录。

2. 使用Stream API进行数据分组

Java Stream API提供了一个强大的收集器Collectors.groupingBy()，它可以轻松实现基于某个属性的元素分组。

分组实现：

// 继续上面的main方法
// 根据"Account"键的值对列表进行分组
List>> groupedByAccount =
        new ArrayList<>(dataListMap.stream()
                .collect(Collectors.groupingBy(item -> item.get("Account")))
                .values());

System.out.println("按账户分组后的数据:");
groupedByAccount.forEach(list -> {
    System.out.println("--- 账户组 ---");
    list.forEach(System.out::println);
});
System.out.println("\n---");

代码解析：

1. dataListMap.stream(): 将原始List转换为一个Stream，以便进行链式操作。
2. collect(Collectors.groupingBy(item -> item.get("Account"))): 这是核心的分组操作。
   • Collectors.groupingBy()是一个终端操作，它将Stream中的元素收集到一个Map中。
   • item -> item.get("Account")是分类函数（classifier function），它为Stream中的每个Map元素提供一个键（即“Account”的值）。所有具有相同键的元素将被收集到一个List中。
   • 此操作的结果是一个Map>>，其中键是账户ID（如"220", "230"），值是对应账户的所有交易记录组成的列表。
3. .values(): 从上述Map中提取所有值，这些值是List
4. new ArrayList(): 将Collection转换为我们最终所需的List>>。

输出示例：

按账户分组后的数据:
--- 账户组 ---
{Charged fare=3, Trip ID=1, Account=220}
{Charged fare=5, Trip ID=2, Account=220}
--- 账户组 ---
{Charged fare=7, Trip ID=3, Account=230}
{Charged fare=8, Trip ID=4, Account=230}

3. 将分组后的列表重新扁平化

在某些场景下，我们可能需要将已经分组的List>>重新合并回一个单一的List

扁平化实现：

// 继续上面的main方法
// 将分组后的数据重新扁平化为一个列表
List> regroupedList = groupedByAccount.stream()
        .flatMap(Collection::stream)
        .collect(Collectors.toList());

System.out.println("重新扁平化后的数据:");
regroupedList.forEach(System.out::println);
System.out.println("\n---");

代码解析：

1. groupedByAccount.stream(): 将List>>转换为一个Stream>>。
2. flatMap(Collection::stream): 这是扁平化的关键操作。
   • flatMap操作符接收一个函数，该函数将Stream中的每个元素（在这里是List
   • Collection::stream是一个方法引用，它将每个内部的List
   • flatMap会将所有这些生成的内部Stream“扁平化”成一个单一的Stream
3. collect(Collectors.toList()): 将扁平化后的Stream中的所有元素收集到一个新的List

输出示例：

重新扁平化后的数据:
{Charged fare=3, Trip ID=1, Account=220}
{Charged fare=5, Trip ID=2, Account=220}
{Charged fare=7, Trip ID=3, Account=230}
{Charged fare=8, Trip ID=4, Account=230}

可以看到，结果与原始的dataListMap在内容上是一致的。

4. 注意事项与最佳实践

• Stream的非侵入性： Stream API的操作是惰性的，并且不会修改原始集合。这意味着dataListMap在执行分组和扁平化操作后，其内容仍然保持不变。你可以安全地重复使用原始列表。
• 处理null键： 如果用于分组的键（例如"Account"）可能为null，item.get("Account")也可能返回null。Collectors.groupingBy()默认会处理null键，将其归入一个特殊的null组。如果需要更精细的控制（例如，过滤掉null键的记录），可以在stream()之后添加filter()操作。

  // 过滤掉Account为null的记录再分组
  List>> groupedFiltered =
          new ArrayList<>(dataListMap.stream()
                  .filter(item -> item.get("Account") != null)
                  .collect(Collectors.groupingBy(item -> item.get("Account")))
                  .values());

• 性能考量： 对于大型数据集，Stream API通常能提供良好的性能，因为它能够利用多核处理器的优势进行并行处理（通过.parallelStream()）。然而，对于非常小的数据集，直接的迭代可能更简单且性能差异不明显。
• 可读性： Stream API的链式调用使得代码意图清晰，减少了样板代码，提高了可读性。

5. 总结

本教程演示了如何使用Java Stream API高效地对List