Java中将包含嵌套列表的对象列表扁平化为单一元素列表的转换技巧-java教程-PHP中文网

Java中将包含嵌套列表的对象列表扁平化为单一元素列表的转换技巧

霞舞

发布： 2025-10-23 13:50:01

原创

524人浏览过

Java中将包含嵌套列表的对象列表扁平化为单一元素列表的转换技巧

本文探讨了在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版本。

缺点:

表单大师AI

一款基于自然语言处理技术的智能在线表单创建工具，可以帮助用户快速、高效地生成各类专业表单。

查看详情

代码相对冗长，可读性可能不如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提供了一个可能更高效和灵活的替代方案，值得尝试。