在现代数据处理中，将扁平化的数据结构转换为更具层次感的嵌套结构是常见的需求，尤其是在为前端界面或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字段。
立即学习“Java免费学习笔记（深入）”；
期望的输出结构（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
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
// ... (接上文代码)
// 阶段二：将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 
