Java Stream实现数据分组与嵌套结构转换教程_技术教程

本教程详细讲解如何利用Java Stream API，将扁平化的数据列表（如数据库查询结果）通过groupingBy和mapping等收集器，高效地转换为按指定字段分组的、包含嵌套子列表的JSON友好结构。文章将通过具体代码示例，展示从原始数据到目标结构的完整转换过程，并提供实现细节和注意事项。

在现代数据处理中，将扁平化的数据结构转换为更具层次感的嵌套结构是常见的需求，尤其是在为前端界面或api提供数据时。本教程将以一个具体的场景为例，演示如何利用java 8及更高版本提供的stream api，优雅且高效地完成这一转换。

1. 问题描述与目标结构

假设我们有一个数据库查询结果，它返回一个包含多个Response对象的列表。每个Response对象都包含一个ID以及两段相关数据sData和sName。

原始数据结构（Response接口）

public interface Response {
    Long getId();
    String getSData();
    String getSName();
}

示例输入数据（转换为JSON格式）

[
  {"id":1,"sData":"UK,FR","sName":"X"},
  {"id":2,"sData":"UK,FR","sName":"Y"},
  {"id":4,"sData":"EU","sName":"X"},
  {"id":4,"sData":"Others","sName":"O"}
]

我们的目标是根据id字段对这些Response对象进行分组，并将每个组内的sData和sName信息聚合到一个嵌套的子列表中。最终输出的结构将是一个NewResponse对象的列表，每个NewResponse包含一个id和一个subDataList，其中subDataList是SubData对象的列表。需要注意的是，在最终输出的SubData中，原始Response的sName将映射到SubData的sData字段，而原始Response的sData将映射到SubData的sName字段。

期望的输出结构（NewResponse和SubData类）

// 子数据结构
public class SubData {
    private String sData; // 对应原始Response的sName
    private String sName; // 对应原始Response的sData

    public SubData(String sData, String sName) {
        this.sData = sData;
        this.sName = sName;
    }
    // Getters
    public String getSData() { return sData; }
    public String getSName() { return sName; }
    // (可添加setter, equals, hashCode, toString方法)
}

// 最终输出结构
public class NewResponse {
    private Long id;
    private List subDataList;

    public NewResponse(Long id, List subDataList) {
        this.id = id;
        this.subDataList = subDataList;
    }
    // Getters
    public Long getId() { return id; }
    public List getSubDataList() { return subDataList; }
    // (可添加setter, equals, hashCode, toString方法)
}

期望的输出示例（id=4的情况）

{
    "subDataList" :
          [
              {
                 "sData": "X",    // 对应原始Response的sName
                 "sName": "EU"    // 对应原始Response的sData
              },
              {
                 "sData": "O",
                 "sName": "Others"
              }
          ]
}

2. 核心概念：Java Stream API

Java Stream API 提供了一种声明式处理数据集合的方式，它支持函数式编程范式，使得数据处理逻辑更加简洁和高效。在本教程中，我们将主要使用以下Stream操作：

stream(): 将集合转换为流。
collect(): 终止操作，将流中的元素收集到结果容器中。
Collectors.groupingBy(): 一个强大的收集器，用于根据某个分类函数对流中的元素进行分组，结果是一个Map。
Collectors.mapping(): groupingBy的下游收集器，用于在分组后对每个组内的元素进行进一步的转换（映射）。
Collectors.toList(): mapping的下游收集器，将映射后的元素收集到List中。
map(): 中间操作，对流中的每个元素应用一个函数，将其转换为另一种类型。
entrySet(): Map的方法，返回一个包含Map中所有键值对的Set视图，每个键值对都是一个Map.Entry对象。

3. 实现步骤与代码示例

我们将分两阶段完成数据转换：首先，将原始Response列表分组并映射到Map>；然后，将这个Map转换为List。

3.1 定义辅助类

首先，确保Response接口有一个具体的实现，以便于演示。在实际项目中，这通常是ORM框架生成的实体类。

// Response接口的具体实现，仅用于演示
public class ResponseImpl implements Response {
    private Long id;
    private String sData;
    private String sName;

    public ResponseImpl(Long id, String sData, String sName) {
        this.id = id;
        this.sData = sData;
        this.sName = sName;
    }

    @Override
    public Long getId() { return id; }
    @Override
    public String getSData() { return sData; }
    @Override
    public String getSName() { return sName; }

    @Override
    public String toString() {
        return "ResponseImpl{" + "id=" + id + ", sData='" + sData + '\'' + ", sName='" + sName + '\'' + '}';
    }
}

SubData和NewResponse类如前文所示。

3.2 第一阶段：分组与子数据映射

使用groupingBy将Response列表按id分组，同时使用mapping将每个组内的Response对象转换为SubData对象，并收集到列表中。

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.*; // 方便静态导入收集器方法

// ... (Response, SubData, NewResponse, ResponseImpl 类定义)

public class DataTransformer {

    public static void main(String[] args) {
        // 模拟原始数据
        List responses = Arrays.asList(
            new ResponseImpl(1L, "UK,FR", "X"),
            new ResponseImpl(2L, "UK,FR", "Y"),
            new ResponseImpl(4L, "EU", "X"),
            new ResponseImpl(4L, "Others", "O")
        );

        // 阶段一：分组并映射子数据
        // 结果：Map>
        Map> groupedMap = responses.stream()
            .collect(groupingBy(Response::getId, // 根据id分组
                    mapping(r -> new SubData(r.getSName(), r.getSData()), // 映射为SubData，注意字段顺序
                            toList()))); // 将映射后的SubData收集到List中

        System.out.println("分组后的中间结果 (Map>):");
        groupedMap.forEach((id, subDataList) ->
            System.out.println("ID: " + id + ", SubDataList: " + subDataList)
        );
    }
}

解释：

groupingBy(Response::getId)：这是主收集器，它根据Response对象的id属性进行分组。
mapping(r -> new SubData(r.getSName(), r.getSData()), toList())：这是groupingBy的下游收集器。对于每个分组，它会执行以下操作：
- r -> new SubData(r.getSName(), r.getSData())：将每个Response对象r转换为一个新的SubData对象。根据目标结构，我们将Response的sName作为SubData的第一个参数（即SubData.sData），将Response的sData作为SubData的第二个参数（即SubData.sName）。
- toList()：将所有转换后的SubData对象收集到一个List中。

3.3 第二阶段：转换为目标对象列表

groupedMap现在包含了我们所需的所有分组信息。接下来，我们将遍历这个Map的entrySet()，将每个键值对（id和List）转换为一个NewResponse对象。

// ... (接上文代码)

        // 阶段二：将Map转换为List
        List finalResult = groupedMap.entrySet()
            .stream() // 将Map的entrySet转换为流
            .map(entry -> new NewResponse(entry.getKey(), entry.getValue())) // 将每个Entry映射为NewResponse对象
            .collect(toList()); // 收集到List中

        System.out.println("\n最终结果 (List):");
        finalResult.forEach(System.out::println);

        // 也可以将上述两个阶段的操作链式调用，代码更紧凑
        List chainedResult = responses.stream()
            .collect(groupingBy(Response::getId,
                    mapping(r -> new SubData(r.getSName(), r.getSData()), toList())))
            .entrySet()
            .stream()
            .map(entry -> new NewResponse(entry.getKey(), entry.getValue()))
            .collect(toList());

        System.out.println("\n链式调用结果 (List):");
        chainedResult.forEach(System.out::println);
    }
}

完整代码示例（包含所有辅助类）

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.*;

// 原始数据接口
interface Response {
    Long getId();
    String getSData();
    String getSName();
}

// Response接口的具体实现，用于演示
class ResponseImpl implements Response {
    private Long id;
    private String sData;
    private String sName;

    public ResponseImpl