使用 Java 8 Stream API 将 List 转换为 Map

" />

本文将指导你如何使用 Java 8 Stream API 将 List 转换为 Map>。 这种转换在处理具有嵌套结构的数据时非常有用，例如当我们需要根据嵌套对象的属性对外部对象进行分组时。

使用 Stream API 进行转换

假设我们有以下两个领域类：Trip 和 Employee。

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;
import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Trip {
    private Date startTime;
    private Date endTime;
    List empList;
}

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Employee {
    private String name;
    private String empId;
}

我们的目标是将一个 List 转换为 Map>，其中 Map 的 Key 是 Employee 对象的 empId，Value 是包含该 Employee 参与的所有 Trip 对象的列表。

为了实现这个目标，我们需要使用 Stream API 中的 flatMap 和 groupingBy 操作。flatMap 用于将一个 Stream 中的每个元素转换为另一个 Stream，并将所有生成的 Stream 连接成一个 Stream。groupingBy 用于将 Stream 中的元素按照指定的条件进行分组。

立即学习“Java免费学习笔记（深入）”；

首先，我们需要创建一个辅助类，用于保存 Employee 的 empId 和对应的 Trip 对象。 在 Java 16 及以上版本，可以使用 record 来简化这个过程。

InsCode

InsCode 是CSDN旗下的一个无需安装的编程、协作和分享社区

下载

public record TripEmployee(String empId, Trip trip) {}

对于Java 8，可以使用如下的class来实现同样的功能：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
class TripEmployee {
    private String empId;
    private Trip trip;
}

接下来，我们可以使用以下代码将 List 转换为 Map>：

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

public class TripConverter {

    public static Map> convertTripsToEmployeeMap(List trips) {
        return trips.stream()
                .flatMap(trip -> trip.getEmpList().stream()
                        .map(emp -> new TripEmployee(emp.getEmpId(), trip))
                )
                .collect(Collectors.groupingBy(
                        TripEmployee::empId,
                        Collectors.mapping(TripEmployee::trip,
                                Collectors.toList())
                ));
    }

    public static void main(String[] args) {
        // 创建一些示例数据
        List employees1 = new ArrayList<>();
        employees1.add(new Employee("Alice", "1"));
        employees1.add(new Employee("Bob", "2"));

        List employees2 = new ArrayList<>();
        employees2.add(new Employee("Charlie", "3"));
        employees2.add(new Employee("Alice", "1"));

        Trip trip1 = new Trip(new java.util.Date(), new java.util.Date(), employees1);
        Trip trip2 = new Trip(new java.util.Date(), new java.util.Date(), employees2);

        List trips = new ArrayList<>();
        trips.add(trip1);
        trips.add(trip2);

        // 进行转换
        Map> employeeTripMap = convertTripsToEmployeeMap(trips);

        // 打印结果
        employeeTripMap.forEach((empId, tripList) -> {
            System.out.println("Employee ID: " + empId);
            tripList.forEach(trip -> System.out.println("  Trip: " + trip));
        });
    }
}

这段代码首先使用 flatMap 将每个 Trip 对象转换为一个 Stream，其中每个 TripEmployee 对象包含一个 Employee 的 empId 和对应的 Trip 对象。然后，使用 groupingBy 将 TripEmployee 对象按照 empId 进行分组，并将每个 empId 对应的 Trip 对象收集到一个列表中。

代码解释

1. trips.stream(): 将 List 转换为一个 Stream。
2. flatMap(trip -> trip.getEmpList().stream().map(emp -> new TripEmployee(emp.getEmpId(), trip))): 对于 Stream 中的每个 Trip 对象，获取其 empList，将其转换为一个 Stream，并将每个 Employee 对象映射为一个 TripEmployee 对象。flatMap 将所有生成的 Stream 连接成一个 Stream。
3. collect(Collectors.groupingBy(TripEmployee::empId, Collectors.mapping(TripEmployee::trip, Collectors.toList()))): 使用 groupingBy 将 TripEmployee 对象按照 empId 进行分组。Collectors.mapping 用于将每个 empId 对应的 TripEmployee 对象映射为 Trip 对象，并使用 Collectors.toList() 将所有 Trip 对象收集到一个列表中。

注意事项

• 确保 Trip 类的 getEmpList() 方法返回的 List 不为 null，否则可能会导致 NullPointerException。
• 如果 Employee 类的 getEmpId() 方法返回 null 或空字符串，可能会导致 groupingBy 的结果出现问题。建议在代码中进行空值或空字符串的检查。
• record 是 Java 16 引入的特性，如果你的项目使用的是 Java 8，你需要使用 class 来代替 record。

总结

本文介绍了如何使用 Java 8 Stream API 将一个 Trip 对象的列表转换为一个 Map>，其中 Map 的 Key 是员工 ID，Value 是包含该员工参与的所有 Trip 对象的列表。通过使用 flatMap 和 groupingBy 组合的 Stream 操作，我们可以简洁而高效地实现这种转换。这种方法在处理具有嵌套结构的数据时非常有用，可以帮助我们更好地组织和分析数据。