Kotlin Nested Data Structures: Organizing and Managing Complex Data

Introduction

Welcome to our exploration of Compound Data Structures in Kotlin . Having navigated through Maps, Sets, and Lists, we'll delve into nested maps and lists . These structures enable us to handle complex and hierarchical data, which is typical in real-world scenarios. This lesson will guide you through a recap of the basics, the creation and modification of nested maps and lists, as well as common error handling.

Recap: Maps, Lists, and Understanding Nested Structures

Here's a simple example of a school directory that uses a map with grades as keys and lists of students as values: Kotlin fun main() {// Map with grades as keys and lists of students as values val schoolDirectory = mapOf("Grade1" to listOf("Amy", "Bobby", "Charlie"), "Grade2" to listOf("David", "Eve", "Frank"), "Grade3" to listOf("George", "Hannah", "Ivy")) // Prints the Grade1 list in the map println(schoolDirectory["Grade1"]) // Output: [Amy, Bobby, Charlie]}

Creating Nested Maps and Lists

Just like their non-nested versions, creating nested structures is straightforward. Kotlin's data classes can be leveraged for better organization when needed. Nested Map: Kotlin fun main() {// Map within a map val nestedMap = mapOf("fruit" to mapOf("apple" to "red", "banana" to "yellow"), "vegetable" to mapOf("carrot" to "orange", "spinach" to "green")) // Prints the nested map println(nestedMap) // Output: {fruit={apple=red, banana=yellow}, vegetable={carrot=orange, spinach=green}}} Nested List: Kotlin fun main() {// Lists within a list val nestedList = listOf(listOf(1, 2, 3), // inner list within the outer list listOf(4, 5, 6), // another inner list within the outer list listOf(7, 8, 9) // third inner list within the outer list) // Prints the nested list println(nestedList) // Output: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]} Lists within a Map: Kotlin fun main() {// Lists within a map val listMap = mapOf("numbers" to listOf(1, 2, 3), "letters" to listOf("a", "b", "c")) // Prints the map of lists println(listMap) // Output: {numbers=[1, 2, 3], letters=[a, b, c]}}

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 maps or lists follows rules similar to those for their non-nested counterparts.

From Nested Map:

Kotlin

fun main() {
    val nestedMap = mapOf(
        "fruit" to mapOf(
            "apple" to "red",
            "banana" to "yellow"
        ),
        "vegetable" to mapOf(
            "carrot" to "orange",
            "spinach" to "green"
        )
    )

    // Accessing apple's color from nested map
    println(nestedMap["fruit"]?.get("apple")) // Output: red
}

fun main() {
    val nestedMap = mapOf(
        "fruit" to mapOf(
            "apple" to "red",
            "banana" to "yellow"
        ),
        "vegetable" to mapOf(
            "carrot" to "orange",
            "spinach" to "green"
        )
    )

    // Accessing apple's color from nested map
    println(nestedMap["fruit"]?.get("apple")) // Output: red
}

The notation used to access values from a nested map involves chaining the access operations. Here's a breakdown:

Accessing the Outer Map:
- nestedMap["fruit"]: This accesses the value associated with the key "fruit" in the outer map. The value is another map (mapOf("apple" to "red", "banana" to "yellow")).
Safe Call Operator (?.):
- ?. is used to safely access the inner map. If "fruit" does not exist in nestedMap, the expression evaluates to null, preventing a null pointer exception.
Accessing the Inner Map:
- .get("apple"): This accesses the value associated with the key "apple" in the inner map. The value is "red", which is then printed.

Overall, println(nestedMap["fruit"]?.get("apple")) safely accesses and prints the color of the apple from the nested map structure, outputting "red". From Nested List:

Kotlin

fun main() {
    val nestedList = listOf(
        listOf(1, 2, 3),
        listOf(4, 5, 6),
        listOf(7, 8, 9)
    )

    // Accessing the 3rd value from the 2nd list in nested list
    println(nestedList[1][2]) // Output: 6
}

fun main() {
    val nestedList = listOf(
        listOf(1, 2, 3),
        listOf(4, 5, 6),
        listOf(7, 8, 9)
    )

    // Accessing the 3rd value from the 2nd list in nested list
    println(nestedList[1][2]) // Output: 6
}

From Both:

Kotlin

fun main() {
    val listMap = mapOf(
        "numbers" to listOf(1, 2, 3),
        "letters" to listOf("a", "b", "c")
    )

    // Accessing the second letter in the 'letters' list in listMap
    println(listMap["letters"]?.get(1)) // Output: b    
}

fun main() {
    val listMap = mapOf(
        "numbers" to listOf(1, 2, 3),
        "letters" to listOf("a", "b", "c")
    )

    // Accessing the second letter in the 'letters' list in listMap
    println(listMap["letters"]?.get(1)) // Output: b    
}

Identifying Errors and Handling Exceptions

Kotlin provides try/catch blocks for error handling. Below is an example of handling potential null pointer exceptions when accessing nested collections.

Kotlin

fun main() {
    val nestedMap = mapOf(
        "fruit" to mapOf(
            "apple" to "red"
        )
    )

    // Trying to print a non-existent key in nestedMap
    try {
        val color = nestedMap["fruit"]?.get("mango") ?: throw NoSuchElementException("Key not found!")
        println(color)
    } catch (e: NoSuchElementException) {
        println(e.message)
    }
}

fun main() {
    val nestedMap = mapOf(
        "fruit" to mapOf(
            "apple" to "red"
        )
    )

    // Trying to print a non-existent key in nestedMap
    try {
        val color = nestedMap["fruit"]?.get("mango") ?: throw NoSuchElementException("Key not found!")
        println(color)
    } catch (e: NoSuchElementException) {
        println(e.message)
    }
}

In this code block, the try/catch mechanism is used to handle potential exceptions gracefully when accessing a non-existent key in a nested map. Here's how it works:

try Block:
- The try block encloses the code that might throw an exception.
- In this case, nestedMap["fruit"]?.get("mango") attempts to access the color of "mango" from the inner map associated with the "fruit" key.
- Because "mango" does not exist in the map, the expression evaluates to null.
Elvis Operator (?:):
- ?: is used to handle the case where the expression on the left is null.
- If the result of nestedMap["fruit"]?.get("mango") is null, the Elvis operator triggers the throwing of a NoSuchElementException with the message "Key not found!".
catch Block:
- The catch block captures the NoSuchElementException if it is thrown in the try block.
- Within the catch block, println(e.message) prints the exception message "Key not found!" to the console.

Alternatively, you can use Kotlin's let function combined with the Elvis operator for more elegant error handling:

Kotlin

fun main() {
    val nestedMap = mapOf(
        "fruit" to mapOf(
            "apple" to "red"
        )
    )

    // Attempting to access a non-existent key with error handling using `let`
    val color = nestedMap["fruit"]?.get("apple")?.let {
        println("Apple color found: $it")
        it
    } ?: run {
        // Executed if `let` didn't find a non-null value
        println("Key not found! Defaulting to unknown color.")
        "unknown"
    }

    println("Final color value is $color")
}

fun main() {
    val nestedMap = mapOf(
        "fruit" to mapOf(
            "apple" to "red"
        )
    )

    // Attempting to access a non-existent key with error handling using `let`
    val color = nestedMap["fruit"]?.get("apple")?.let {
        println("Apple color found: $it")
        it
    } ?: run {
        // Executed if `let` didn't find a non-null value
        println("Key not found! Defaulting to unknown color.")
        "unknown"
    }

    println("Final color value is $color")
}

In this second example, let is employed to safely operate on the non-null color value. If the color is found, it prints a success message and returns the color. If the value is null, the Elvis operator with run provides a fallback, printing an error message and returning a default value. This approach offers a functional way to handle potential null values while maintaining code readability.

This use of error handling allows the program to avoid crashing due to accessing non-existent keys and provides user-friendly feedback instead.

Introduction

Recap: Maps, Lists, and Understanding Nested Structures

Creating Nested Maps and Lists

Join the 1M+ learners on CodeSignal

Accessing Values in Nested Structures

Common Operations on these Structures

Identifying Errors and Handling Exceptions

Lesson Summary