Nested HashMaps Examples in Java

1. Overview

In this tutorial, we’ll look at how to deal with nested HashMaps in Java. We’ll also see how to create and compare them. Finally, we’ll also see how to remove and add records to the inner maps.

2. Use Cases

Nested HashMap is very helpful in storing JSON or JSON-like structures where objects are embedded inside one another. For example, a structure or JSON similar to:

{
    "type": "donut",
    "batters":
    {
        “batter”:
        [
            { "id": "1001", "type": "Regular" },
            { "id": "1002", "type": "Chocolate" },
            { "id": "1003", "type": "Blueberry" },
            { "id": "1004", "type": "Devil's Food" }
        ]
    }
} 

is a perfect candidate for a nested HashMap. In general, whenever we need to embed one object in another object, we can use them.

3. Create a HashMap

There are multiple ways to create a HashMap, such as manually constructing the maps or using Streams and grouping functions. The Map structure can be both with primitive types as well as Objects.

3.1. Using the put() Method

We can build a nested HashMap by manually creating the inner maps and then inserting them into the outer Map using the put method:

public Map<Integer, String> buildInnerMap(List<String> batterList) {
     Map<Integer, String> innerBatterMap = new HashMap<Integer, String>();
     int index = 1;
     for (String item : batterList) {
         innerBatterMap.put(index, item);
         index++;
     }
     return innerBatterMap;
}

We can test it with:

assertThat(mUtil.buildInnerMap(batterList), is(notNullValue()));
Assert.assertEquals(actualBakedGoodsMap.keySet().size(), 2);
Assert.assertThat(actualBakedGoodsMap, IsMapContaining.hasValue(equalTo(mUtil.buildInnerMap(batterList))));

3.2. Using Streams

If we have a List that we want to convert to a Map, we can create a stream and then convert it to a Map using the Collectors.toMap method. Here, we have two examples: one has an inner Map of Strings, and the other is a Map with Integer and Object values.

In the first example, the Employee has the Address object nested inside it. We’re then building a nested HashMap:

Map<Integer, Map<String, String>> employeeAddressMap = listEmployee.stream()
  .collect(Collectors.groupingBy(e -> e.getAddress().getAddressId(),
    Collectors.toMap(f -> f.getAddress().getAddressLocation(), Employee::getEmployeeName)));
return employeeAddressMap;

In the second example, we are building an object of type <Employee id <Address id, Address object>>:

Map<Integer, Map<Integer, Address>> employeeMap = new HashMap<>();
employeeMap = listEmployee.stream().collect(Collectors.groupingBy((Employee emp) -> emp.getEmployeeId(),
  Collectors.toMap((Employee emp) -> emp.getAddress().getAddressId(), fEmpObj -> fEmpObj.getAddress())));
return employeeMap;

4. Iterating Through a Nested HashMap

Iterating through a nested Hashmap is no different from iterating through a regular or unnested HashMap. The only difference between a nested and regular Map is that the values of a nested HashMap are Map type:

for (Map.Entry<String, Map<Integer, String>> outerBakedGoodsMapEntrySet : outerBakedGoodsMap.entrySet()) {
    Map<Integer, String> valueMap = outerBakedGoodsMapEntrySet.getValue();
    System.out.println(valueMap.entrySet());
}

for (Map.Entry<Integer, Map<String, String>> employeeEntrySet : employeeAddressMap.entrySet()) {
    Map<String, String> valueMap = employeeEntrySet.getValue();
    System.out.println(valueMap.entrySet());
}

5. Comparing Nested HashMaps

There are many ways to compare HashMaps in Java. We can compare them using the equals() method. The default implementation compares each value.

If we change the inner Map’s contents, the equality check fails. If the inner objects are all new instances every time in the case of user-defined objects, the equality check will also fail. Similarly, if we change the outer Map‘s contents, the equality check will fail as well:

assertNotEquals(outerBakedGoodsMap2, actualBakedGoodsMap);

outerBakedGoodsMap3.put("Donut", mUtil.buildInnerMap(batterList));
assertNotEquals(outerBakedGoodsMap2, actualBakedGoodsMap);

Map<Integer, Map<String, String>> employeeAddressMap1 = mUtil.createNestedMapfromStream(listEmployee);
assertNotEquals(employeeAddressMap1, actualEmployeeAddressMap);

For the Map with user-defined objects as values, we need to customize the equality method using one of the methods mentioned in the comparing HashMaps article. Otherwise, the checks will fail:

//Comparing a Map<Integer, Map<String, String>> and Map<Integer, Map<Integer, Address>> map
assertNotSame(employeeMap1, actualEmployeeMap);
assertNotEquals(employeeMap1, actualEmployeeMap);
Map<Integer, Map<Integer, Address>> expectedMap = setupAddressObjectMap();
assertNotSame(expectedMap, actualEmployeeMap);
assertNotEquals(expectedMap, actualEmployeeMap);

If both the maps are the same, then the equality check succeeds. For a user-defined map, if all identical objects are moved into another map, the equality check succeeds:

Map<String, Map<Integer, String>> outerBakedGoodsMap4 = new HashMap<>();
outerBakedGoodsMap4.putAll(actualBakedGoodsMap);
assertEquals(actualBakedGoodsMap, outerBakedGoodsMap4);
Map<Integer, Map<Integer, Address>> employeeMap1 = new HashMap<>();
employeeMap1.putAll(actualEmployeeMap);
assertEquals(actualEmployeeMap, employeeMap1);

6. Adding Elements to Nested HashMaps

To add an element to the inner Map of the nested HashMap, we first have to retrieve it. We can retrieve the inner object using the get() method. Then we can use the put() method on the inner Map object and insert the new values:

assertEquals(actualBakedGoodsMap.get("Cake").size(), 5);
actualBakedGoodsMap.get("Cake").put(6, "Cranberry");
assertEquals(actualBakedGoodsMap.get("Cake").size(), 6);

If we have to add an entry to the outer Map, we need to supply the correct entries for the inner Maps as well:

outerBakedGoodsMap.put("Eclair", new HashMap<Integer, String>() {
    {
        put(1, "Dark Chocolate");
    }
});

7. Deleting Records from Nested HashMaps

To delete the record from the inner Map, first, we need to retrieve it and then use the remove() method to delete it. If there is only one value in the inner Map, then a null object is left as the value:

assertNotEquals(actualBakedGoodsMap.get("Cake").get(5), null);
actualBakedGoodsMap.get("Cake").remove(5);
assertEquals(actualBakedGoodsMap.get("Cake").get(5), null);

assertNotEquals(actualBakedGoodsMap.get("Eclair").get(1), null);
actualBakedGoodsMap.get("Eclair").remove(1);
assertEquals(actualBakedGoodsMap.get("Eclair").get(1), null);
actualBakedGoodsMap.put("Eclair", new HashMap<Integer, String>() {
    {
        put(1, "Dark Chocolate");
    }
});

If we remove a record from the outer Map, Java deletes both, the inner and outer Map records, which is evident since the inner Map is the “value” of the outer Map:

assertNotEquals(actualBakedGoodsMap.get("Eclair"), null);
actualBakedGoodsMap.remove("Eclair");
assertEquals(actualBakedGoodsMap.get("Eclair"), null);

8. Flatten a Nested HashMap

One alternative to a nested HashMap is to use combined keys. A combined key usually concatenates the two keys from the nested structure with a dot in between. For example, the combined key would be Donut.1, Donut.2, and so on. We can “flatten,” i.e., convert from nested Map structure to a single Map structure:

var flattenedBakedGoodsMap = mUtil.flattenMap(actualBakedGoodsMap);
assertThat(flattenedBakedGoodsMap, IsMapContaining.hasKey("Donut.2"));
var flattenedEmployeeAddressMap = mUtil.flattenMap(actualEmployeeAddressMap);
assertThat(flattenedEmployeeAddressMap, IsMapContaining.hasKey("200.Bag End"));

The combined keys approach overcomes the extra memory storage disadvantages that come with nested HashMaps. However, the combined keys approach is not very good at scaling.

9. Conclusion

In this article, we saw how to create, compare, update and flatten a nested HashMap.