如何使用lambdas/streams将嵌套的对象列表转换为映射(map)

Question

我正在使用两个for循环将下面的对象结构列表转换为一个HashMap,如下所示。

public class Vehical {

    private Category category;
    private List<Brand> brandList;

    public Category getCategory() {
        return category;
    }

    public List<Brand> getBrandList() {
        return brandList;
    }
}

public class Category {

    private Integer catId;

    public Integer getCatId() {
        return catId;
    }       
}

public class Brand {

    private Model model;

    public Model getModel() {
        return model;
    }
}

public class Model {

    private List<Reg> regList;

    public List<Reg> getRegList() {
        return regList;
    }

}

public class Reg {

    private Integer regId;

    public Integer getRegId() {
        return regId;
    }
}

public static void main(String[] args) {

    //Assume that filled with data.*** 
    List<Vehical> vehicalList = getVehicals();

    Map<Integer, Map<Integer, Brand>> vehicalMap = new HashMap<Integer, Map<Integer, Brand>>();

    for (Vehical vehical : vehicalList) {

        Map<Integer, Brand> brandMap = new HashMap<Integer, Brand>();

        for (Brand brand : vehical.getBrandList()) {
            //Assume that zeroth index is always available and getting "RegId" from the zeroth element is fixed.***
            brandMap.put(brand.getModel().getRegList().get(0).getRegId(), brand);
        }
        vehicalMap.put(vehical.getCategory().getCatId(), brandMap);
    }

}

我如何使用lambdas/streams做同样的事情呢？我试过用平面地图，但没用。流式传输时无法访问嵌套得注册区域.

Map<Integer, Map<Integer, Brand>> vehicalMap = new HashMap<>();

vehicalList.forEach(v -> {
    Map<Integer, Brand> brandMap = new HashMap<>();
    v.getBrandList().stream().forEach(b -> brandMap
            .put(b.getModel().getRegList().get(0).getRegId(), b));

    vehicalMap.put(v.getCategory().getCatId(), brandMap);
});

基于@Nidhish Krishnan答案更新工作代码示例

Answer 1

试试这个

如果你想根据分组得到结果，试试这个

Map<Integer, Map<Integer, Brand>> vehicalMap = getVehicals().stream()
    .collect(Collectors.groupingBy(vechiles -> vechiles.getCategory().getCatId(),
        Collectors.collectingAndThen(
                Collectors.groupingBy(vechile -> vechile.getBrandList().get(0).getModel().getRegList().get(0).getRegId()),
                e ->e.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, v -> v.getValue().get(0).getBrandList().get(0)))
        )
    ))
    .entrySet().stream()
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

如果您不想使用分组，请尝试下面的分组

Map<Integer, Map<Integer, Brand>> vehicalMap = getVehicals().stream()
    .collect(Collectors.toMap(
        vechile -> vechile.getCategory().getCatId(),
        vechile -> vechile.getBrandList().stream()
                .collect(Collectors.toMap(
                        brands -> brands.getModel().getRegList().get(0).getRegId(), 
                        brand -> brand, (a, b) -> b)), 
        (a, b) -> a));

不确定VehicalList的数据，这就是我创建测试VehicalList的方法

private static List<Vehical> getVehicals() {
    return Lists.newArrayList(
        new Vehical(new Category(21), Lists.newArrayList(new Brand(new Model(Lists.newArrayList(new Reg(100), new Reg(101), new Reg(102)))))),
        new Vehical(new Category(22), Lists.newArrayList(new Brand(new Model(Lists.newArrayList(new Reg(200), new Reg(201), new Reg(202)))))),
        new Vehical(new Category(23), Lists.newArrayList(new Brand(new Model(Lists.newArrayList(new Reg(300), new Reg(301), new Reg(302)))))),
        new Vehical(new Category(24), Lists.newArrayList(new Brand(new Model(Lists.newArrayList(new Reg(400), new Reg(401), new Reg(402)))))),
        new Vehical(new Category(25), Lists.newArrayList(new Brand(new Model(Lists.newArrayList(new Reg(500), new Reg(501), new Reg(502)))))),
        new Vehical(new Category(26), Lists.newArrayList(new Brand(new Model(Lists.newArrayList(new Reg(600), new Reg(601), new Reg(602)))))),
        new Vehical(new Category(26), Lists.newArrayList(new Brand(new Model(Lists.newArrayList(new Reg(700), new Reg(701), new Reg(702))))))
    );
}