How to convert a nested list of objects into a map (Map<Integer, Map<Integer, Object>>) using lambdas/streams - arraylist

Question

I'm converting the following list of objects structure to a HashMap using two for loops as shown below.
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);
}
}
How can I do the same thing using lambdas/streams?
I tried with a flatMap, but it didn't work. Couldn't access the nested RegId while streaming.
Also, I tried with forEach but finally it looks likes the same for loop solution.
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);
});
Any help would be appreciated.
UPDATE
Working code sample based on #Nidhish Krishnan answer

Answer 1

Try this out
SOLUTION 1
If you want to get the result based on grouping, try this one
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));
SOLUTION 2
If you don't want to use grouping try the below one
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));
UPDATE 1
Not sure what data you are having for vehicalList, this is how I created the test 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))))))
);
}

Answer 2

Let say, I have entity class TableColumnInfo
public class TableColumnInfo {
#Column(name = "table_name")
private String tableName;
#Column(name = "column_name")
private String columnName;
#Column(name = "data_type")
private String dataType;
#Column(name = "is_nullable")
private Boolean isNullable;
#Column(name = "column_default")
private String columnDefault;
}
In input, I am given List of Object as below:
List<TableColumnInfo> tableColumnInfoRes = some database repository call;
In output, I want nested MAP as below:
Map<String, Map<String, TableColumnInfo>>
Where:
Outter Map Key: String i.e. tableName
Outter Map Value: Map
Inner Map Key: String i.e. columnName
Inner Map Value: Object i.e. TableColumnInfo
Constraints:
Outter map tableName and Inner map column name must belong to same object.
It means, for every tableName in outter map, inner map must have a column name as a key and entire object as a value (1:1 Mapping)
Solution:
Using Java Functional programming and Collections
Below BiFunction used to generate inner Map
BiFunction<List<TableColumnInfo>, String, Map<String, TableColumnInfo>> mapper1 =
(infoList, tableName2) ->
{ Map<String, TableColumnInfo> res =
infoList.stream().filter(infoList2 -> infoList2.getTableName().equals(tableName2))
.collect(Collectors.toMap(TableColumnInfo::getColumnName, Function.identity()));
return res;
};
Below code used to produce outter map
Map<String, Map<String, TableColumnInfo>> tableColumnMap = tableColumnInfoRes.stream()
.collect(Collectors.toMap(
tableInfo -> tableInfo.getTableName(),
tableInfo -> mapper1.apply(tableColumnInfoRes,tableInfo.getTableName()),
(a,b)->b
));
In above code, BIFunction is called for every table name.
In Inner Map, to produce value as object, make use of Function.identity()
For outter map, to avoid conflict of key, make use of (a,b) -> b
Constraints are satisfied in BiFunction using filters on stream.