Java Stream API：过滤嵌套Map并保持对象结构完整性-java教程-PHP中文网

Java Stream API：过滤嵌套Map并保持对象结构完整性

碧海醫心

发布： 2025-10-11 12:58:34

原创

116人浏览过

java stream api：过滤嵌套map并保持对象结构完整性

在使用Java Stream API处理嵌套数据结构时，如何在过滤内部集合（如Map）的同时，确保外部对象的非过滤字段保持不变是一个常见挑战。直接收集过滤后的内部元素往往会导致父对象属性丢失。本教程将演示如何利用Stream API过滤嵌套Map，并重新构建父对象以包含过滤后的数据，从而在保持原始数据结构及其所有字段完整性的前提下完成数据处理。

理解嵌套数据结构与过滤需求

在现代应用程序中，处理复杂、嵌套的数据结构是家常便饭。例如，我们可能有一个Manage类，其中包含一个Map<String, Vehicle>，而每个Vehicle对象又包含自己的name、model以及一个Map<String, Service>。

public class Manage {
    Map<String, Vehicle> vehicles;

    // 构造函数、Getter/Setter等省略

    public static class Vehicle {
        String name;
        String model;
        Map<String, Service> services;

        // 构造函数
        public Vehicle(String name, String model, Map<String, Service> services) {
            this.name = name;
            this.model = model;
            this.services = services;
        }

        // Getter方法
        public String getName() { return name; }
        public String getModel() { return model; }
        public Map<String, Service> getServices() { return services; }

        // Setter方法（如果需要，但此处为简化教程，我们倾向于创建新实例）
    }

    public static class Service {
        String id;
        String report;

        // 构造函数
        public Service(String id, String report) {
            this.id = id;
            this.report = report;
        }

        // Getter方法
        public String getId() { return id; }
        public String getReport() { return report; }
    }
}

登录后复制

我们的目标是：从vehicles Map中筛选出那些其Vehicle对象包含特定服务（例如，服务键为s-1）的条目。更重要的是，对于这些筛选出的Vehicle对象，我们希望只保留其services Map中键为s-1的服务，同时保持Vehicle对象本身的name和model等字段不变。

常见误区：直接收集内部Map导致信息丢失

初学者在使用Stream API处理此类问题时，常会尝试直接对内部Map进行过滤并收集，如下所示：

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

即构数智人

即构数智人是由即构科技推出的AI虚拟数字人视频创作平台，支持数字人形象定制、短视频创作、数字人直播等。

查看详情

// 这是一个错误的示例，会导致name和model字段丢失
/*
vehicles.entrySet()
    .stream()
    .filter(entry -> entry.getValue().getServices().containsKey("s-1"))
    .collect(Collectors.toMap(Map.Entry::getKey,
        entry -> entry.getValue()
            .getServices()
            .entrySet()
            .stream()
            .filter(subEntry -> subEntry.getKey().equals("s-1"))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))));
*/

登录后复制

上述代码的问题在于，Collectors.toMap的第二个参数（值映射器）最终返回的是一个Map<String, Service>，而不是一个Vehicle对象。这意味着原始Vehicle对象中的name和model字段在最终的结果中被完全丢弃了，这与我们的需求不符。我们需要的是一个包含过滤后services Map的新Vehicle对象。

正确方法：过滤内部Map并重建父对象

要解决上述问题，核心思想是：当对嵌套结构进行过滤时，如果需要保留父对象的其他字段，就必须在过滤内部集合后，使用父对象的原始字段和过滤后的内部集合，重新创建一个父对象实例。

以下是实现这一目标的完整示例代码：

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class DataProcessingTutorial {

    public static class Manage {
        Map<String, Vehicle> vehicles;

        public Manage(Map<String, Vehicle> vehicles) {
            this.vehicles = vehicles;
        }

        public Map<String, Vehicle> getVehicles() {
            return vehicles;
        }

        public static class Vehicle {
            String name;
            String model;
            Map<String, Service> services;

            public Vehicle(String name, String model, Map<String, Service> services) {
                this.name = name;
                this.model = model;
                this.services = services;
            }

            public String getName() { return name; }
            public String getModel() { return model; }
            public Map<String, Service> getServices() { return services; }

            @Override
            public String toString() {
                return "Vehicle{" +
                       "name='" + name + '\'' +
                       ", model='" + model + '\'' +
                       ", services=" + services +
                       '}';
            }
        }

        public static class Service {
            String id;
            String report;

            public Service(String id, String report) {
                this.id = id;
                this.report = report;
            }

            public String getId() { return id; }
            public String getReport() { return report; }

            @Override
            public String toString() {
                return "Service{" +
                       "id='" + id + '\'' +
                       ", report='" + report + '\'' +
                       '}';
            }
        }
    }

    public static void main(String[] args) {
        // 1. 初始化数据
        Map<String, Manage.Vehicle.Service> vehicle1Services = new HashMap<>();
        vehicle1Services.put("s-1", new Manage.Service("s-1", "Engine Check"));
        vehicle1Services.put("s-2", new Manage.Service("s-2", "Oil Change"));

        Map<String, Manage.Vehicle.Service> vehicle2Services = new HashMap<>();
        vehicle2Services.put("s-3", new Manage.Service("s-3", "Tire Rotation"));

        Map<String, Manage.Vehicle.Service> vehicle3Services = new HashMap<>();
        vehicle3Services.put("s-1", new Manage.Service("s-1", "Brake Inspection"));
        vehicle3Services.put("s-4", new Manage.Service("s-4", "Alignment"));

        Map<String, Manage.Vehicle> vehicles = new HashMap<>();
        vehicles.put("v-1", new Manage.Vehicle("CarA", "ModelX", vehicle1Services));
        vehicles.put("v-2", new Manage.Vehicle("CarB", "ModelY", vehicle2Services));
        vehicles.put("v-3", new Manage.Vehicle("CarC", "ModelZ", vehicle3Services));

        // 2. 使用Stream API进行过滤和重构
        Map<String, Manage.Vehicle> vehiclesFiltered = vehicles.entrySet()
            .stream()
            // 筛选出包含 "s-1" 服务的车辆
            .filter(entry -> entry.getValue().getServices() != null && entry.getValue().getServices().containsKey("s-1"))
            .collect(Collectors.toMap(
                Map.Entry::getKey, // 保持原始的车辆键
                entry -> {
                    // 过滤当前车辆的 services Map，只保留键为 "s-1" 的服务
                    Map<String, Manage.Vehicle.Service> filteredServices =
                        entry.getValue().getServices()
                            .entrySet().stream()
                            .filter(subEntry -> subEntry.getKey().equals("s-1"))
                            .collect(Collectors.toMap(
                                Map.Entry::getKey,
                                Map.Entry::getValue
                            ));
                    // 使用原始的 name、model 和过滤后的 services 创建一个新的 Vehicle 实例
                    return new Manage.Vehicle(
                        entry.getValue().getName(),
                        entry.getValue().getModel(),
                        filteredServices
                    );
                }
            ));

        // 3. 打印结果
        System.out.println("原始车辆数据:");
        vehicles.forEach((k, v) -> System.out.println(k + ": " + v));
        System.out.println("\n过滤后的车辆数据 (只保留 's-1' 服务，并保持结构):");
        vehiclesFiltered.forEach((k, v) ->

登录后复制

以上就是Java Stream API：过滤嵌套Map并保持对象结构完整性的详细内容，更多请关注php中文网其它相关文章！