Java Stream API处理嵌套Map时保留原始结构的最佳实践

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

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

        // 构造函数、Getter和Setter（为简化示例，这里省略，但实际应用中是必需的）
        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; }

        public static class Service {
            String id;
            String report;

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

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

// 这种尝试会丢失Vehicle的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))));
*/

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

public class DataProcessor {

    // 假设 Manage 类和 Vehicle, Service 类已定义如上

    public static Map<String, Manage.Vehicle> filterVehiclesAndServices(
            Map<String, Manage.Vehicle> originalVehicles) {

        // 1. 过滤主Map的Entry，只保留包含目标服务的Vehicle
        // 2. 对于每个符合条件的Vehicle，重新构建一个新的Vehicle实例
        //    新实例的name和model沿用原始Vehicle的，services Map则经过过滤
        Map<String, Manage.Vehicle> vehiclesFiltered = originalVehicles.entrySet()
            .stream()
            .filter(entry -> entry.getValue().getServices().containsKey("s-1")) // 筛选包含"s-1"服务的车辆
            .collect(Collectors.toMap(
                Map.Entry::getKey, // 车辆的键保持不变
                entry -> {
                    // 获取原始车辆对象
                    Manage.Vehicle originalVehicle = entry.getValue();

                    // 过滤services Map，只保留键为"s-1"的服务
                    Map<String, Manage.Vehicle.Service> filteredServices =
                        originalVehicle.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(
                        originalVehicle.getName(),
                        originalVehicle.getModel(),
                        filteredServices
                    );
                }
            ));
        return vehiclesFiltered;
    }

    public static void main(String[] args) {
        // 示例数据初始化
        Map<String, Manage.Vehicle.Service> services1 = new HashMap<>();
        services1.put("s-1", new Manage.Vehicle.Service("s-1", "Report A"));
        services1.put("s-2", new Manage.Vehicle.Service("s-2", "Report B"));

        Map<String, Manage.Vehicle.Service> services2 = new HashMap<>();
        services2.put("s-3", new Manage.Vehicle.Service("s-3", "Report C"));

        Map<String, Manage.Vehicle.Service> services3 = new HashMap<>();
        services3.put("s-1", new Manage.Vehicle.Service("s-1", "Report D"));
        services3.put("s-4", new Manage.Vehicle.Service("s-4", "Report E"));

        Map<String, Manage.Vehicle> originalVehicles = new HashMap<>();
        originalVehicles.put("car1", new Manage.Vehicle("BMW", "X5", services1));
        originalVehicles.put("car2", new Manage.Vehicle("Audi", "A4", services2)); // 不包含s-1
        originalVehicles.put("car3", new Manage.Vehicle("Mercedes", "C200", services3));

        System.out.println("原始车辆数据:");
        originalVehicles.forEach((k, v) -> {
            System.out.println("Key: " + k + ", Name: " + v.getName() + ", Model: " + v.getModel() + ", Services: " + v.getServices().keySet());
        });

        // 执行过滤
        Map<String, Manage.Vehicle> filteredVehicles = filterVehiclesAndServices(originalVehicles);

        System.out.println("\n过滤后的车辆数据:");
        filteredVehicles.forEach((k, v) -> {
            System.out.println("Key: " + k + ", Name: " + v.getName() + ", Model: " + v.getModel() + ", Services: " + v.getServices().keySet());
        });
    }
}