Nested HashMap in Java

Java's basic data structure, HashMap, enables programmers to store and retrieve data effectively. Nesting of HashMap is a useful notion when working with complex data structures. In this section, we will discuss nested HashMap, its benefits, and implementation in applications. Comprehending and Applying a Map of Maps in Java, Keys, and values are frequently mapped in Java using the Map interface. Occasionally, it becomes necessary to create a Map of Maps, or nested maps. For example, this data structure can be used to store student names and IDs for various classes.

What is a Nested HashMap?

A nested HashMap is one in which each of the values linked to a key is another HashMap. The representation of increasingly complicated data structures is made possible by this nesting, which enables us to establish a hierarchy of key-value pairs.

Now let's explore the main ideas and techniques related to nested hash maps.

Methods for Working with Nested HashMaps

1. Adding Values

// Adding values to the nested map
HashMap<Integer, String> hm = new HashMap<>();
hm.put(20,"score1");
hm.put(45,"score2");
hm.put( hm, "Ram");

2. Accessing Values

Accessing values from a nested HashMap requires two levels of key retrieval.

int johnScore1 = nestedMap.get("John").get("score1");
System.out.println("John's score1: " + johnScore1);

3. Iterating through Nested HashMap

for (String outerKey: nestedMap.keySet()) {
    System.out.print("Outer key: " + outerKey);
    HashMap<String, Integer> im = nestedMap.get(outerKey);
    for (String ik : im.keySet()) {
        int value = im.get(ik);
        System.out.print("Inner key Value: " + ik + ", Value: " + value);
    }
}

4. Removing Values

5. Checking if a Key Exists

To check if a key exists in a nested HashMap:

if (nestedMap.containsKey("John")) {
    // Do something
}

NestedHashMap.java

import java.util.*;
public class Main {
    public static void main(String[] args) {
        // Declare variables
        int bcaSize = 0;
        int mcaSize = 0;
        Map<Object, String> bcaStudentsMap = new HashMap<Object, String>();
        Map<Object, String> mcaStudentsMap = new HashMap<Object, String>();
        Scanner sc = new Scanner(System.in);
        System.out.println("Please enter total number of BCA students:");
        bcaSize = Integer.parseInt(sc.nextLine());
        System.out.println("Please enter total number of MCA students:");
        mcaSize = Integer.parseInt(sc.nextLine());
        for (int k = 1; k <= bcaSize; k++) {
            int id = 100;
            String sn = "";
            System.out.println("Please enter name of the " + k + "st student of BCA:");
            name = sc.nextLine();
            System.out.println("Student ID = " + (id + k ) + "    Student Name = " + sn);
            id = id + k ;
            bcaStudentsMap.put(Integer.valueOf(id), sn);
        }
        for (int k = 1; k <= mcaSize; k++) {
            int id = 100;
            String sn = "";
            System.out.println("Enter the name of the " + k + "st student of MCA:");
            name = sc.nextLine();
            System.out.println("Student ID = " + (id + k) + "    Student Name = " + sn);
            id = id + k;
            mcaStudentsMap.put(Integer.valueOf(id), sn);
        }
        Map<String, Object> sm = new HashMap<String, Object>();
        sm.put("BCA", bcaStudentsMap);
        sm.put("MCA", mcaStudentsMap);
        // Print studentsMap
        System.out.println("Map of Map:   " + sm);
        // Print elements of studentsMap
        for (String course : sm.keySet()) {
            ArrayList<Object> data = new ArrayList<Object>(((Map<Object, String>) sm.get(course)).keySet());
           for (Object ot : data) {
                System.out.println("Courses: " + course + " Student IDs: " + ot + " Name of Student: " +
                        ((Map<Object, String>) sm.get(course)).get(ot));
            }        }
        sc.close();
    }
}

Output:

Enter the total number of BCA students:
2
Enter the total number of MCA students:
2
Enter the name of the 1st student of BCA:
Ram
Student ID = 101    Student Name = Ram
Enter the name of the 2st student of BCA:
Seetha
Student ID = 102    Student Name = Seetha
Enter the name of the 1st student of MCA:
Ravi
Student ID = 101    Student Name = Ravi
Enter the name of the 2st student of MCA:
Geetha
Student ID = 102    Student Name = Geetha
Map of Map:   {BCA={101=Ram, 102=Seetha}, MCA={101=Ravi, 102=Geetha}}
Course: BCA Student ID: 101 Student Name: Ram
Course: BCA Student ID: 102 Student Name: Seetha
Course: MCA Student ID: 101 Student Name: Ravi
Course: MCA Student ID: 102 Student Name: Geetha

Conclusion

In conclusion, handling complicated data structures may be done elegantly with the help of a Map of Maps implementation in Java, particularly when dealing with hierarchical relationships like storing student information for several courses. The example demonstrated how to efficiently organize and access data using nested hash maps.

Next TopicNumber Series Program in Java

← prev next →