欢迎来到奈瑶·映南科技互联网学院
技术教程

Java Streams：将嵌套Map扁平化并映射为DTO列表的实战指南

花韻仙語 次阅读

本教程详细讲解如何利用java 8 stream api将一个map>结构的数据扁平化，并将其中的person对象转换为persondto列表。文章重点阐述flatmap和map操作符的使用，以及如何处理异构数据类型（object）和日期格式化，旨在提供一个清晰、专业的解决方案。

引言：数据转换的挑战

在实际的Java应用开发中，我们经常需要对复杂的数据结构进行转换。例如，从数据库或外部服务获取的数据可能以嵌套的Map形式存在，而我们的业务逻辑或前端展示可能需要一个扁平化的DTO（Data Transfer Object）列表。本教程将聚焦于一个具体的场景：将一个Map>类型的数据源，通过Java 8的Stream API，转换为一个List。此过程中，我们还需要处理源数据中某个属性的异构数据类型（如Integer、String、LocalDate），并对日期进行格式化。

场景描述与数据模型

假设我们有一个数据集合，它以Map>的形式存储，其中String键代表一个ID，List包含多个与该ID关联的Person对象。每个Person对象包含以下信息：

  • id: 字符串类型，标识符。
  • tag: 枚举类型Value (如VALUE1, VALUE2, VALUE3)。
  • specificValue: Object类型，用于存储异构数据，例如整数、文本或日期。
  • eventDate: LocalDate类型，表示事件日期。
  • message: 字符串类型，附加信息。

我们的目标是将其转换为一个List，其中PersonDto的结构如下：

  • tag: 枚举类型Value。
  • id: 字符串类型。
  • date: 格式化后的日期字符串。
  • result: Object类型，对应Person中的specificValue。

为了更好地理解，我们定义相关的Java类和枚举：

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

// 定义Value枚举
public enum Value {
    VALUE1, VALUE2, VALUE3
}

// 源数据模型：Person类
class Person {
    private String id;
    private Value tag;
    private Object specificValue; // 可以是Integer, String, LocalDate等
    private LocalDate eventDate;
    private String message;

    public Person(String id, Value tag, Object specificValue, LocalDate eventDate, String message) {
        this.id = id;
        this.tag = tag;
        this.specificValue = specificValue;
        this.eventDate = eventDate;
        this.message = message;
    }

    // Getters
    public String getId() { return id; }
    public Value getTag() { return tag; }
    public Object getSpecificValue() { return specificValue; }
    public LocalDate getEventDate() { return eventDate; }
    public String getMessage() { return message; }

    @Override
    public String toString() {
        return "Person{" +
               "id='" + id + '\'' +
               ", tag=" + tag +
               ", specificValue=" + specificValue +
               ", eventDate=" + eventDate +
               ", message='" + message + '\'' +
               '}';
    }
}

// 目标数据模型：PersonDto类
class PersonDto {
    private Value tag;
    private String id;
    private String date; // 格式化后的日期字符串
    private Object result; // 对应Person的specificValue

    public PersonDto(Value tag, String id, String date, Object result) {
        this.tag = tag;
        this.id = id;
        this.date = date;
        this.result = result;
    }

    // Getters
    public Value getTag() { return tag; }
    public String getId() { return id; }
    public String getDate() { return date; }
    public Object getResult() { return result; }

    @Override
    public String toString() {
        return "PersonDto{" +
               "tag=" + tag +
               ", id='" + id + '\'' +
               ", date='" + date + '\'' +
               ", result=" + result +
               '}';
    }
}

使用Java Stream API进行数据转换

核心的转换逻辑将利用Stream API的flatMap和map操作。

  1. 获取Map中的所有值（List）的Stream： persons.values().stream()会创建一个Stream>。

  2. 扁平化Stream： 由于我们最终需要一个List，而不是一个List>，我们需要将Stream>扁平化为Stream。这正是flatMap操作符的作用。flatMap(List::stream)将每个List转换为一个Stream，然后将这些单独的Stream连接成一个单一的Stream。

  3. 映射为PersonDto： 现在我们有了一个Stream，可以使用map操作符将每个Person对象转换为一个PersonDto对象。在转换过程中，我们需要注意以下几点：

    • Person的tag直接映射到PersonDto的tag。
    • Person的id直接映射到PersonDto的id。
    • Person的eventDate（LocalDate类型）需要通过DateTimeFormatter格式化为字符串，然后映射到PersonDto的date。
    • Person的specificValue（Object类型）直接映射到PersonDto的result。

  4. 收集结果： 最后，使用collect(Collectors.toList())将转换后的Stream收集到一个List中。

完整示例代码

下面是实现上述转换的完整Java代码：

public class StreamTransformationExample {

    // 定义日期格式化器
    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy");

    public static void main(String[] args) {
        // 1. 准备源数据
        Map> personsData = new HashMap<>();

        // 模拟数据
        LocalDate date1 = LocalDate.of(2000, 10, 10);
        LocalDate date2 = LocalDate.of(2000, 10, 10);
        LocalDate date3 = LocalDate.of(2000, 10, 10);
        LocalDate date4 = LocalDate.of(2000, 10, 10);
        LocalDate date5 = LocalDate.of(2000, 10, 10);
        LocalDate date6 = LocalDate.of(2000, 10, 10);


        personsData.put("p1", Arrays.asList(
                new Person("p1", Value.VALUE1, 10, date1, "Message"),
                new Person("p1", Value.VALUE2, "Text", date3, "Message"),
                new Person("p1", Value.VALUE3, LocalDate.of(2000, 11, 11), date5, "Message")
        ));
        personsData.put("p2", Arrays.asList(
                new Person("p2", Value.VALUE1, 20, date2, "Message"),
                new Person("p2", Value.VALUE2, "Text", date4, "Message"),
                new Person("p2", Value.VALUE3, LocalDate.of(2000, 11, 12), date6, "Message")
        ));

        System.out.println("--- 原始数据 ---");
        personsData.forEach((key, value) -> System.out.println(key + ": " + value));
        System.out.println("\n--- 转换后的DTO列表 ---");

        // 2. 使用Stream API进行转换
        List resultDtos = personsData.values().stream()
                .flatMap(List::stream) // 扁平化Stream> 为 Stream
                .map(person -> new PersonDto(
                        person.getTag(),                     // PersonDto的tag
                        person.getId(),                      // PersonDto的id
                        formatter.format(person.getEventDate()), // 格式化日期为字符串
                        person.getSpecificValue()            // PersonDto的result (Object类型)
                ))
                .collect(Collectors.toList()); // 收集为List

        // 3. 打印结果
        resultDtos.forEach(System.out::println);
    }
}

运行上述代码，将得到如下输出：

--- 原始数据 ---
p1: [Person{id='p1', tag=VALUE1, specificValue=10, eventDate=2000-10-10, message='Message'}, Person{id='p1', tag=VALUE2, specificValue=Text, eventDate=2000-10-10, message='Message'}, Person{id='p1', tag=VALUE3, specificValue=2000-11-11, eventDate=2000-10-10, message='Message'}]
p2: [Person{id='p2', tag=VALUE1, specificValue=20, eventDate=2000-10-10, message='Message'}, Person{id='p2', tag=VALUE2, specificValue=Text, eventDate=2000-10-10, message='Message'}, Person{id='p2', tag=VALUE3, specificValue=2000-11-12, eventDate=2000-10-10, message='Message'}]

--- 转换后的DTO列表 ---
PersonDto{tag=VALUE1, id='p1', date='10-10-2000', result=10}
PersonDto{tag=VALUE2, id='p1', date='10-10-2000', result=Text}
PersonDto{tag=VALUE3, id='p1', date='10-10-2000', result=2000-11-11}
PersonDto{tag=VALUE1, id='p2', date='10-10-2000', result=20}
PersonDto{tag=VALUE2, id='p2', date='10-10-2000', result=Text}
PersonDto{tag=VALUE3, id='p2', date='10-10-2000', result=2000-11-12}

关键概念与注意事项

  1. flatMap 的作用：flatMap是处理嵌套集合的关键。它将一个包含多个集合的流（例如Stream>）转换成一个包含所有集合元素的单一流（Stream），从而避免了多层循环的复杂性，使代码更简洁、更具声明性。
  2. map 的作用：map操作用于将流中的每个元素一对一地转换为另一种类型的元素。在本例中，它将每个Person对象转换为一个PersonDto对象。
  3. 处理异构数据类型（Object）：当某个属性可能包含不同类型的数据时（如Integer、String、LocalDate），将其定义为Object类型是常见的做法。Stream API在映射时会直接传递这个Object引用，不需要额外的类型转换（除非在PersonDto中需要进一步处理）。在实际应用中，如果需要对Object类型的值进行后续操作，通常需要进行类型检查或模式匹配。
  4. 日期格式化：java.time.format.DateTimeFormatter是Java 8中处理日期时间格式化的标准工具。使用formatter.format(localDate)可以方便地将LocalDate对象转换为指定格式的字符串。
  5. 代码可读性：使用Stream API可以使数据转换逻辑更加清晰和简洁。链式调用使得数据流向一目了然，提高了代码的可读性和可维护性。
  6. 性能考量：对于大规模数据，Stream API通常能提供良好的性能，因为它能够利用多核处理器进行并行处理（通过parallelStream()）。然而，对于小规模数据，传统循环的性能开销可能更小。在大多数业务场景下，Stream API的简洁性和可读性优势更为突出。

总结

本教程展示了如何利用Java 8 Stream API高效地将一个复杂的嵌套Map数据结构扁平化，并将其中的对象映射为目标DTO列表。通过flatMap和map操作的组合，我们能够优雅地处理集合的扁平化、对象的转换、异构数据类型的传递以及日期格式化等常见的数据处理需求。掌握这些Stream操作对于编写现代、高效且易于维护的Java代码至关重要。

ai 应用开发 工具 处理器 yy 前端 java stream java类 代码可读性

相关文章

按ESC键退出。