Compound Data Structures in Java

Welcome to our exploration of Compound Data Structures in Java . Having navigated through Maps, Sets, and Arrays, we'll delve into nested HashMaps and arrays . These structures enable us to handle complex and hierarchical data, which is typical in real-world scenarios. Nested data structures are commonly used to represent data models like organizational charts, product categories, and multi-dimensional datasets. This lesson will guide you through a recap of the basics, as well as the creation and modification of nested HashMaps and arrays .

Recap: Maps, Arrays, and Understanding Nested Structures

As a quick recap, Arrays are mutable, ordered collections, while HashMaps are collections of key-value pairs with unique keys. These structures can be nested. Here's a simple example of a school directory: Java import java.util.HashMap; public class Solution {public static void main(String[] args) {// HashMap with grades as keys and arrays of students as values HashMap<String, String[]> schoolDirectory = new HashMap<>(); schoolDirectory.put("Grade1", new String[] { "Amy", "Bobby", "Charlie" }); schoolDirectory.put("Grade2", new String[] { "David", "Eve", "Frank" }); schoolDirectory.put("Grade3", new String[] { "George", "Hannah", "Ivy" }); // Logs the Grade1 array in the HashMap System.out.println(String.join(", ", schoolDirectory.get("Grade1"))); // Output: Amy, Bobby, Charlie}} In this example, we have a HashMap where each key represents a grade, and the corresponding value is an array of student names. This is a simple demonstration of a nested data structure.

Creating Nested HashMaps and Arrays

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Accessing Values in Nested Structures

The retrieval of values from nested HashMaps or arrays follows rules similar to those for their non-nested counterparts.

From Nested HashMap:

Java

import java.util.HashMap;

public class Solution {
    public static void main(String[] args) {
        // HashMap within a HashMap
        HashMap<String, HashMap<String, String>> nestedMap = new HashMap<>();
        nestedMap.put("fruit", new HashMap<>() {{
            put("apple", "red");
            put("banana", "yellow");
        }});
        nestedMap.put("vegetable", new HashMap<>() {{
            put("carrot", "orange");
            put("spinach", "green");
        }});

        // Accessing apple's color from the nested HashMap
        System.out.println(nestedMap.get("fruit").get("apple")); // Output: red
    }
}

import java.util.HashMap;

public class Solution {
    public static void main(String[] args) {
        // HashMap within a HashMap
        HashMap<String, HashMap<String, String>> nestedMap = new HashMap<>();
        nestedMap.put("fruit", new HashMap<>() {{
            put("apple", "red");
            put("banana", "yellow");
        }});
        nestedMap.put("vegetable", new HashMap<>() {{
            put("carrot", "orange");
            put("spinach", "green");
        }});

        // Accessing apple's color from the nested HashMap
        System.out.println(nestedMap.get("fruit").get("apple")); // Output: red
    }
}

Here, we navigate the nested HashMap structure by chaining the key lookups. First, we access the "fruit" HashMap, then the "apple" key within it.

From Nested Array:

Java

public class Solution {
    public static void main(String[] args) {
        // Arrays within an array
        int[][] nestedArray = {
            { 1, 2, 3 },
            { 4, 5, 6 },
            { 7, 8, 9 }
        };

        // Accessing the 3rd value from the 2nd array in the nested array
        System.out.println(nestedArray[1][2]); // Output: 6
    }
}

public class Solution {
    public static void main(String[] args) {
        // Arrays within an array
        int[][] nestedArray = {
            { 1, 2, 3 },
            { 4, 5, 6 },
            { 7, 8, 9 }
        };

        // Accessing the 3rd value from the 2nd array in the nested array
        System.out.println(nestedArray[1][2]); // Output: 6
    }
}

In the nested array, we access elements using double indexing. Here, nestedArray[1][2] retrieves the third element of the second array.

From Nested HashMaps and Arrays:

Java

import java.util.HashMap;

public class Solution {
    public static void main(String[] args) {
        // Arrays within a HashMap
        HashMap<String, int[]> arrayMap = new HashMap<>();
        arrayMap.put("numbers", new int[] { 1, 2, 3 });
        arrayMap.put("letters", new int[] { 10, 11, 12 });

        // Accessing the second number in the 'letters' array in arrayMap
        System.out.println(arrayMap.get("letters")[1]); // Output: 11
    }
}

import java.util.HashMap;

public class Solution {
    public static void main(String[] args) {
        // Arrays within a HashMap
        HashMap<String, int[]> arrayMap = new HashMap<>();
        arrayMap.put("numbers", new int[] { 1, 2, 3 });
        arrayMap.put("letters", new int[] { 10, 11, 12 });

        // Accessing the second number in the 'letters' array in arrayMap
        System.out.println(arrayMap.get("letters")[1]); // Output: 11
    }
}

This example demonstrates accessing a value from an array that is itself a value in a HashMap.

Error Handling in Nested Data Structures

While retrieving data from nested HashMaps or arrays, it's important to handle potential errors gracefully. This can be done using conditional checks or try-catch blocks.

Error Handling with Nested HashMaps and Arrays:

For nested HashMaps and arrays, check the existence of keys and valid indices.

Java

import java.util.HashMap;

public class Solution {
    public static void main(String[] args) {
        // HashMap within a HashMap
        HashMap<String, HashMap<String, String>> nestedMap = new HashMap<>();
        nestedMap.put("fruit", new HashMap<>() {{
            put("apple", "red");
            put("banana", "yellow");
        }});
        nestedMap.put("vegetable", new HashMap<>() {{
            put("carrot", "orange");
            put("spinach", "green");
        }});

        // Safely accessing the color of apple
        if (nestedMap.containsKey("fruit") && nestedMap.get("fruit").containsKey("apple")) {
            System.out.println(nestedMap.get("fruit").get("apple")); // Output: red
        } else {
            System.err.println("The key 'apple' or 'fruit' does not exist.");
        }

        // Arrays within a HashMap
        HashMap<String, int[]> arrayMap = new HashMap<>();
        arrayMap.put("numbers", new int[] { 1, 2, 3 });
        arrayMap.put("letters", new int[] { 10, 11, 12 });

        // Safely accessing the second letter in the 'letters' array
        if (arrayMap.containsKey("letters") && arrayMap.get("letters").length > 1) {
            System.out.println(arrayMap.get("letters")[1]); // Output: 11
        } else {
            System.err.println("The key 'letters' or index is out of bounds.");
        }
    }
}

import java.util.HashMap;

public class Solution {
    public static void main(String[] args) {
        // HashMap within a HashMap
        HashMap<String, HashMap<String, String>> nestedMap = new HashMap<>();
        nestedMap.put("fruit", new HashMap<>() {{
            put("apple", "red");
            put("banana", "yellow");
        }});
        nestedMap.put("vegetable", new HashMap<>() {{
            put("carrot", "orange");
            put("spinach", "green");
        }});

        // Safely accessing the color of apple
        if (nestedMap.containsKey("fruit") && nestedMap.get("fruit").containsKey("apple")) {
            System.out.println(nestedMap.get("fruit").get("apple")); // Output: red
        } else {
            System.err.println("The key 'apple' or 'fruit' does not exist.");
        }

        // Arrays within a HashMap
        HashMap<String, int[]> arrayMap = new HashMap<>();
        arrayMap.put("numbers", new int[] { 1, 2, 3 });
        arrayMap.put("letters", new int[] { 10, 11, 12 });

        // Safely accessing the second letter in the 'letters' array
        if (arrayMap.containsKey("letters") && arrayMap.get("letters").length > 1) {
            System.out.println(arrayMap.get("letters")[1]); // Output: 11
        } else {
            System.err.println("The key 'letters' or index is out of bounds.");
        }
    }
}

By incorporating these conditional checks before accessing the data, we avoid runtime exceptions that could disrupt program execution.

Using try-catch for Error Handling:

Alternatively, you can use try-catch blocks to handle errors.

Java

import java.util.HashMap;

public class Solution {
    public static void main(String[] args) {
        // HashMap within a HashMap
        HashMap<String, HashMap<String, String>> nestedMap = new HashMap<>();
        nestedMap.put("fruit", new HashMap<>() {{
            put("apple", "red");
            put("banana", "yellow");
        }});
        nestedMap.put("vegetable", new HashMap<>() {{
            put("carrot", "orange");
            put("spinach", "green");
        }});

        // Using try-catch to access the color of apple safely
        try {
            System.out.println(nestedMap.get("fruit").get("apple")); // Output: red
        } catch (Exception ex) {
            System.err.println("Error accessing nested key: " + ex.getMessage());
        }

        // Arrays within a HashMap
        HashMap<String, int[]> arrayMap = new HashMap<>();
        arrayMap.put("numbers", new int[] { 1, 2, 3 });
        arrayMap.put("letters", new int[] { 10, 11, 12 });

        // Using try-catch to access the second letter in the 'letters' array safely
        try {
            System.out.println(arrayMap.get("letters")[1]); // Output: 11
        } catch (Exception ex) {
            System.err.println("Error accessing HashMap with array: " + ex.getMessage());
        }
    }
}

import java.util.HashMap;

public class Solution {
    public static void main(String[] args) {
        // HashMap within a HashMap
        HashMap<String, HashMap<String, String>> nestedMap = new HashMap<>();
        nestedMap.put("fruit", new HashMap<>() {{
            put("apple", "red");
            put("banana", "yellow");
        }});
        nestedMap.put("vegetable", new HashMap<>() {{
            put("carrot", "orange");
            put("spinach", "green");
        }});

        // Using try-catch to access the color of apple safely
        try {
            System.out.println(nestedMap.get("fruit").get("apple")); // Output: red
        } catch (Exception ex) {
            System.err.println("Error accessing nested key: " + ex.getMessage());
        }

        // Arrays within a HashMap
        HashMap<String, int[]> arrayMap = new HashMap<>();
        arrayMap.put("numbers", new int[] { 1, 2, 3 });
        arrayMap.put("letters", new int[] { 10, 11, 12 });

        // Using try-catch to access the second letter in the 'letters' array safely
        try {
            System.out.println(arrayMap.get("letters")[1]); // Output: 11
        } catch (Exception ex) {
            System.err.println("Error accessing HashMap with array: " + ex.getMessage());
        }
    }
}

Using try-catch blocks, we can catch and handle exceptions for more robust error management.

Common Operations on These Structures

The modification of nested arrays and HashMaps is similar to that of their non-nested versions.

Java

import java.util.HashMap;
import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        // HashMap within a HashMap
        HashMap<String, HashMap<String, String>> nestedMap = new HashMap<>();
        nestedMap.put("fruit", new HashMap<>() {{
            put("apple", "red");
            put("banana", "yellow");
        }});
        nestedMap.put("vegetable", new HashMap<>() {{
            put("carrot", "orange");
            put("spinach", "green");
        }});

        // Modifying spinach's color to red
        nestedMap.get("vegetable").put("spinach", "red");

        // Print the vegetable HashMap to show modification
        System.out.println("Vegetable colors after modification: " + nestedMap.get("vegetable"));

        // Arrays within a nested array
        int[][] nestedArray = {
            { 1, 2, 3 },
            { 4, 5, 6 },
            { 7, 8, 9 }
        };

        // Deleting the 2nd value from the 3rd array in nested array
        int[] tempArray = new int[nestedArray[2].length - 1];
        for (int i = 0, j = 0; i < nestedArray[2].length; i++) {
            if (i != 1) {
                tempArray[j++] = nestedArray[2][i];
            }
        }
        nestedArray[2] = tempArray;

        // Print the third array to show the deletion
        System.out.println("Third array after deletion: " + Arrays.toString(nestedArray[2]));

        // Deleting apple from the 'fruit' HashMap in nestedMap
        nestedMap.get("fruit").remove("apple");

        // Print the fruit HashMap to show deletion
        System.out.println("Fruit colors after deletion: " + nestedMap.get("fruit"));
    }
}

import java.util.HashMap;
import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        // HashMap within a HashMap
        HashMap<String, HashMap<String, String>> nestedMap = new HashMap<>();
        nestedMap.put("fruit", new HashMap<>() {{
            put("apple", "red");
            put("banana", "yellow");
        }});
        nestedMap.put("vegetable", new HashMap<>() {{
            put("carrot", "orange");
            put("spinach", "green");
        }});

        // Modifying spinach's color to red
        nestedMap.get("vegetable").put("spinach", "red");

        // Print the vegetable HashMap to show modification
        System.out.println("Vegetable colors after modification: " + nestedMap.get("vegetable"));

        // Arrays within a nested array
        int[][] nestedArray = {
            { 1, 2, 3 },
            { 4, 5, 6 },
            { 7, 8, 9 }
        };

        // Deleting the 2nd value from the 3rd array in nested array
        int[] tempArray = new int[nestedArray[2].length - 1];
        for (int i = 0, j = 0; i < nestedArray[2].length; i++) {
            if (i != 1) {
                tempArray[j++] = nestedArray[2][i];
            }
        }
        nestedArray[2] = tempArray;

        // Print the third array to show the deletion
        System.out.println("Third array after deletion: " + Arrays.toString(nestedArray[2]));

        // Deleting apple from the 'fruit' HashMap in nestedMap
        nestedMap.get("fruit").remove("apple");

        // Print the fruit HashMap to show deletion
        System.out.println("Fruit colors after deletion: " + nestedMap.get("fruit"));
    }
}

In this block, we demonstrate various operations, including modifying existing values, adding new elements, and removing elements from nested data structures.

Compound Data Structures in Java