按对象的属性将地图分组到新地图

Question

首先，让我添加实际的“示例代码”：

Map<CarBrand, List<Car>> allCarsAndBrands = new HashMap();

final String bmwBrandName = "BMW";
final String audiBrandName = "AUDI";

List<Car> bmwCars = new ArrayList();
bmwCars.add(new Car(CarType.FAST, "Z4", "silver", bmwBrandName));
bmwCars.add(new Car(CarType.FAST, "M3", "red", bmwBrandName));
bmwCars.add(new Car(CarType.SLOW, "X1", "black", bmwBrandName));

List<Car> audiCars = new ArrayList();
audiCars.add(new Car(CarType.FAST, "S3", "yellow", audiBrandName));
audiCars.add(new Car(CarType.FAST, "R8", "silver", audiBrandName));
audiCars.add(new Car(CarType.SLOW, "A1", "white", audiBrandName));

allCarsAndBrands.put(new CarBrand(bmwBrandName), bmwCars);
allCarsAndBrands.put(new CarBrand(audiBrandName), audiCars);

Map<CarType, Map<CarBrand, List<Car>>> mappedCars;

问题

我的目标是用CarType 填充mappedCars，这将产生两个大集合：一个包含所有 FAST 车，另一个包含 SLOW 车（或任何未来的“类型”，每个都有前一个带有CarBrand 和相关汽车的地图结构。

我目前无法为这个“在其他地图中包含列表的地图”找到正确使用集合/流。我遇到过其他简单地图/列表的案例，但事实证明这个案例对我来说更棘手。

尝试

这是一个初始代码“尝试”：

mappedCars = allCarsAndBrands.entrySet()
                             .stream()
                             .collect(
                               groupingBy(Car::getType, 
                                 groupingBy(Map.Entry::getKey)
                               )
                             );

我也收到“非静态无法引用错误”（Map.Entry::getKey），但这是因为我未能匹配实际的预期回报（Static context cannot access non-static in Collectors）

此时我只是感到困惑，也尝试使用Collectors.toMap，但仍然无法获得工作分组。

附加内容

以下是此示例的类定义：

class CarBrand {
   CarBrand(String name) {
      this.name = name;
   }
   String name;
}

class Car {
    Car(CarType type, String name, String color, String brandName) {
        this.type = type;
        this.name = name;
        this.color = color;
        this.brandName = brandName;
    }

    public CarType getType() {
        return type;
    }

    CarType type;
    String name;
    String color;
    String brandName;
}

enum CarType {
   FAST,
   SLOW,
}

编辑：“脏”解决方案

这是一个“hackish”解决方案（基于 cmets 的建议，将检查答案！）：

Map<CarType, Map<CarBrand, List<Car>>> mappedCars = allCarsAndBrands
                .values()
                .stream()
                .flatMap(List::stream)
                .collect(Collectors.groupingBy(
                        Car::getType,
                        Collectors.groupingBy(
                                car -> allCarsAndBrands.keySet().stream().filter(brand -> brand.name == car.brandName).findFirst().get(),
                                Collectors.toList()
                        )
                ));

正如 cmets 中提到的（之前应该在此处添加），有一个“业务约束”为解决方案增加了一些限制。我也不想创建一个新的CarBrand，因为在现实世界中，这并不像在此看到的那么简单......但同样，使用原始地图和过滤 + 查找实在是太糟糕了。

Answer 1

通过使用现有模型以及嵌套分组的初始方法，您的思路是正确的。可以通过考虑在迭代条目时扁平化 Map 的值部分来进行改进。

allCarsAndBrands.entrySet().stream()
        .flatMap(e -> e.getValue().stream()
                .map(car -> new AbstractMap.SimpleEntry<>(e.getKey(), car)))

一旦你有了它，分组概念的工作原理几乎相同，但现在默认返回的分组值将改为条目类型。因此还需要mapping。这使得整体解决方案类似于：

Map<CarType, Map<CarBrand, List<Car>>> mappedCars =
        allCarsAndBrands.entrySet().stream()
                .flatMap(e -> e.getValue().stream()
                        .map(car -> new AbstractMap.SimpleEntry<>(e.getKey(), car)))
                .collect(Collectors.groupingBy(e -> e.getValue().getType(),
                        Collectors.groupingBy(Map.Entry::getKey,
                                Collectors.mapping(Map.Entry::getValue,
                                        Collectors.toList()))));

Answer 2

正如 cmets 中所讨论的，如果将 Make 包含为 Car 类的字段，这很容易做到。

根据您的上一条评论，最简单的方法是使用混合解决方案，使用 Stream 和 Java 8 中引入的 Map 接口的其他功能。

数据

Map<CarBrand, List<Car>> allCarsAndBrands = new HashMap<>();

final String bmwBrandName = "BMW";
final String audiBrandName = "AUDI";

List<Car> bmwCars = new ArrayList<>();
bmwCars.add(new Car(CarType.FAST, "Z4", "silver"));
bmwCars.add(new Car(CarType.FAST, "M3", "red"));
bmwCars.add(new Car(CarType.SLOW, "X1", "black"));

List<Car> audiCars = new ArrayList<>();
audiCars.add(new Car(CarType.FAST, "S3", "yellow"));
audiCars.add(new Car(CarType.FAST, "R8", "silver"));
audiCars.add(new Car(CarType.SLOW, "A1", "white"));

allCarsAndBrands.put(new CarBrand(bmwBrandName), bmwCars);
allCarsAndBrands.put(new CarBrand(audiBrandName), audiCars);

流程

这是通过为每个 CarBrand 创建一个 Map<CarType, List<Car>> 然后反转密钥来实现的。您可能不熟悉的唯一新功能是computeIfAbsent

Map<CarType, Map<CarBrand, List<Car>>> map = new HashMap<>();

allCarsAndBrands.forEach((brand, carList) -> {
    Map<CarType, List<Car>> typeMap = carList.stream()
            .collect(Collectors.groupingBy(Car::getType));
    typeMap.forEach((type, lst) -> {
        map.computeIfAbsent(type, value->
                new HashMap<CarBrand, List<Car>>())
                    .computeIfAbsent(brand, value->new ArrayList<>())
                    .addAll(lst);
        }
    );
});

打印结果

map.forEach((carType, brandMap) -> {
    System.out.println(carType);
    brandMap.forEach((brand, carList) -> {
        System.out.println("     " + brand + " -> " + carList);
    });
});

印刷品

FAST
     AUDI -> [{FAST,  S3,  yellow}, {FAST,  R8,  silver}]
     BMW -> [{FAST,  Z4,  silver}, {FAST,  M3,  red}]
SLOW
     AUDI -> [{SLOW,  A1,  white}]
     BMW -> [{SLOW,  X1,  black}]

注意：{} 之间的值是 Car 类的 toString 覆盖。