本文探讨了在java中如何将一个包含嵌套列表的对象列表进行转换，使其生成一个新的列表，其中每个对象内部的嵌套列表只包含一个元素。文章详细介绍了三种实现方式：基于java 7及以前版本的传统循环方法、利用java 8至java 15的stream api结合`flatmap`操作，以及java 16及更高版本引入的`mapmulti`方法。通过示例代码和解释，帮助开发者理解并选择最适合其项目需求的列表转换策略。
在实际的软件开发中，我们经常会遇到需要处理复杂数据结构的情况，例如一个对象列表中包含另一个嵌套列表。有时，业务需求会要求我们将这种“一对多”的结构转换成“一对一”的扁平化结构，即对于原始列表中的每个对象，如果其嵌套列表包含多个元素，则需要创建多个新的父对象，每个新父对象只包含嵌套列表中的一个元素。
考虑以下Java类定义，其中Pmt对象包含一个Transaction对象的列表：
import java.util.List;
import java.util.Collections; // 用于 Collections.singletonList
// 假设 Transaction 是一个简单的POJO
class Transaction {
String transactionId;
String amount;
public Transaction(String transactionId, String amount) {
this.transactionId = transactionId;
this.amount = amount;
}
// Getters and Setters (省略)
}
// Pmt 类，包含一个Transaction列表
class Pmt {
String id;
String b; // 其他属性
List<Transaction> trList;
// 构造函数：用于创建新的Pmt对象
public Pmt(String id, String b, List<Transaction> trList) {
this.id = id;
this.b = b;
this.trList = trList;
}
// 构造函数：用于复制现有Pmt对象的属性，并设置新的trList
public Pmt(Pmt originalPmt, List<Transaction> newTrList) {
this.id = originalPmt.getId();
this.b = originalPmt.getB();
this.trList = newTrList;
}
// Getters
public String getId() { return id; }
public String getB() { return b; }
public List<Transaction> getTrList() { return trList; }
@Override
public String toString() {
return "Pmt{" +
"id='" + id + '\'' +
", b='" + b + '\'' +
", trList=" + trList.stream().map(t -> t.transactionId).collect(java.util.stream.Collectors.joining(", ")) +
'}';
}
}我们的目标是将一个List<Pmt>转换为一个新的List<Pmt>，使得新列表中每个Pmt对象只包含一个Transaction。例如，如果原始列表中有5个Pmt对象，每个Pmt对象有2个Transaction，那么新列表将包含10个Pmt对象。每个新的Pmt对象将保留原始Pmt对象的id和b等属性。
下面将介绍几种在Java中实现这一转换的常用方法。
立即学习“Java免费学习笔记（深入）”；
1. Java 7 及以前版本 (传统循环方式)
在Java 7或更早的版本中，通常通过嵌套的for-each循环来实现这种一对多的列表转换。这种方法直观易懂，即使在Java 8及更高版本中也完全适用。
import java.util.ArrayList;
import java.util.List;
import static java.util.Collections.singletonList; // 静态导入
public class ListTransformationLegacy {
public static List<Pmt> transformPmtList(List<Pmt> pmtList) {
List<Pmt> newList = new ArrayList<>();
for (Pmt p : pmtList) {
for (Transaction tr : p.getTrList()) {
// 为每个Transaction创建一个新的Pmt对象，并将其trList设置为只包含当前Transaction
newList.add(new Pmt(p.getId(), p.getB(), singletonList(tr)));
}
}
return newList;
}
public static void main(String[] args) {
// 示例数据
List<Pmt> originalPmtList = new ArrayList<>();
Pmt pmt1 = new Pmt("P001", "B1", List.of(new Transaction("T001A", "100"), new Transaction("T001B", "200")));
Pmt pmt2 = new Pmt("P002", "B2", List.of(new Transaction("T002A", "300")));
originalPmtList.add(pmt1);
originalPmtList.add(pmt2);
System.out.println("原始列表:");
originalPmtList.forEach(System.out::println);
List<Pmt> transformedList = transformPmtList(originalPmtList);
System.out.println("\n转换后的列表 (Java 7 风格):");
transformedList.forEach(System.out::println);
}
}优点:
- 逻辑清晰，易于理解和调试。
- 兼容所有Java版本。
缺点:
- 代码相对冗长，可读性可能不如Stream API在处理复杂转换时简洁。
2. Java 8 - Java 15 (Stream API - flatMap 方法)
Java 8引入的Stream API为集合操作提供了更函数式、更简洁的表达方式。对于一对多的转换，flatMap操作是理想的选择。flatMap可以将一个流中的每个元素转换为另一个流，然后将所有这些流扁平化为一个单一的流。
import java.util.List;
import java.util.stream.Collectors;
import static java.util.Collections.singletonList;
public class ListTransformationStreamFlatMap {
public static List<Pmt> transformPmtList(List<Pmt> pmtList) {
return pmtList.stream()
// 对于每个Pmt对象，将其trList转换为一个Transaction流
.flatMap(p -> p.getTrList().stream()
// 对于每个Transaction，创建一个新的Pmt对象
.map(tr -> new Pmt(p.getId(), p.getB(), singletonList(tr))))
// 将所有新的Pmt对象收集到一个列表中
.collect(Collectors.toList());
}
public static void main(String[] args) {
// 示例数据 (同上)
List<Pmt> originalPmtList = new ArrayList<>();
Pmt pmt1 = new Pmt("P001", "B1", List.of(new Transaction("T001A", "100"), new Transaction("T001B", "200")));
Pmt pmt2 = new Pmt("P002", "B2", List.of(new Transaction("T002A", "300")));
originalPmtList.add(pmt1);
originalPmtList.add(pmt2);
System.out.println("原始列表:");
originalPmtList.forEach(System.out::println);
List<Pmt> transformedList = transformPmtList(originalPmtList);
System.out.println("\n转换后的列表 (Java 8-15 Stream API 风格 - flatMap):");
transformedList.forEach(System.out::println);
}
}优点:
- 代码更加简洁、声明式，符合函数式编程风格。
- 易于并行化处理（通过.parallelStream()）。
- 可读性在熟悉Stream API的开发者中很高。
缺点:
- 对于不熟悉Stream API的开发者，理解可能需要一定的学习曲线。
3. Java 16 及更高版本 (Stream API - mapMulti 方法)
Java 16引入了mapMulti方法，它提供了一种更灵活的方式来处理一对多（或零对多）的转换，有时可以替代flatMap，并且在某些场景下可能更高效。mapMulti允许你通过一个Consumer来“发出”零个、一个或多个元素到下游流中。
import java.util.List;
import java.util.function.Consumer;
import static java.util.Collections.singletonList;
public class ListTransformationStreamMapMulti {
public static List<Pmt> transformPmtList(List<Pmt> pmtList) {
return pmtList.stream()
// 使用mapMulti进行一对多转换
.mapMulti((Pmt p, Consumer<Pmt> c) -> {
// 对于当前Pmt对象的每个Transaction
p.getTrList().forEach(tr ->
// 发出一个新的Pmt对象到下游流
c.accept(new Pmt(p.getId(), p.getB(), singletonList(tr))));
})
// 将流中的所有元素收集到一个列表中
.toList(); // Java 16+ 的便捷收集方法
}
public static void main(String[] args) {
// 示例数据 (同上)
List<Pmt> originalPmtList = new ArrayList<>();
Pmt pmt1 = new Pmt("P001", "B1", List.of(new Transaction("T001A", "100"), new Transaction("T001B", "200")));
Pmt pmt2 = new Pmt("P002", "B2", List.of(new Transaction("T002A", "300")));
originalPmtList.add(pmt1);
originalPmtList.add(pmt2);
System.out.println("原始列表:");
originalPmtList.forEach(System.out::println);
List<Pmt> transformedList = transformPmtList(originalPmtList);
System.out.println("\n转换后的列表 (Java 16+ Stream API 风格 - mapMulti):");
transformedList.forEach(System.out::println);
}
}优点:
- 在某些场景下，mapMulti可能比flatMap更高效，因为它避免了创建中间流的开销。
- 提供了更大的灵活性，可以根据条件发出或不发出元素。
- 代码意图明确，直接表达了“对于每个输入，可以产生零个、一个或多个输出”。
缺点:
- 仅适用于Java 16及更高版本。
- 对于初次接触的开发者，其Consumer回调的模式可能需要适应。
注意事项与总结
- 不可变性原则： 在所有示例中，我们都强调创建新的Pmt对象而不是修改原始对象。这符合函数式编程的不可变性原则，有助于避免副作用，使代码更健壮、更易于测试和理解。
- Collections.singletonList()： 这个方法用于创建一个只包含一个元素的不可变列表。这比new ArrayList<>(List.of(tr))更高效且内存占用更少，特别适合这种只包含单个元素的场景。
- 空列表处理： 如果原始Pmt对象的trList为空，上述Stream API方法（flatMap和mapMulti）将自动跳过这些Pmt对象，不会生成新的Pmt。传统循环方式也同样处理。
-
选择合适的版本：
- 对于Java 7及更早的项目，传统循环是唯一的选择。
- 对于Java 8-15的项目，flatMap通常是推荐的简洁且强大的解决方案。
- 对于Java 16及更高版本，mapMulti提供了一个可能更高效和灵活的替代方案，值得尝试。
通过以上三种方法，开发者可以根据项目所使用的Java版本和个人偏好，灵活地将包含嵌套列表的对象列表扁平化为每个对象只包含一个元素的结构。选择最适合的方案，可以有效提升代码的可读性、维护性和性能。
