Kotlin LinkedHashMap Class

Introduction

In Kotlin, LinkedHashMap is a hash table and linked list implementation of the MutableMap interface. It maintains the insertion order of its elements, meaning the order in which keys are inserted is preserved. LinkedHashMap is part of the kotlin.collections package and is used for storing and managing data with efficient access, insertion, and deletion operations while maintaining order.

Table of Contents

1. What is LinkedHashMap?
2. Creating a LinkedHashMap
3. Common Operations
4. Examples of LinkedHashMap
5. Real-World Use Case
6. Conclusion

1. What is LinkedHashMap?

LinkedHashMap in Kotlin is a dynamic collection that allows you to store, access, and modify key-value pairs efficiently while maintaining the order of insertion. It is part of the kotlin.collections package and implements the MutableMap interface.

2. Creating a LinkedHashMap

You can create a LinkedHashMap using the constructor or by initializing it with key-value pairs.

Example

val emptyMap = LinkedHashMap<String, Int>() // Creates an empty LinkedHashMap
val mapWithElements = linkedMapOf("one" to 1, "two" to 2, "three" to 3) // Creates a LinkedHashMap with elements

3. Common Operations

LinkedHashMap supports various operations for adding, removing, and accessing key-value pairs.

Adding Elements

• put(key: K, value: V): Adds a key-value pair to the map. If the key already exists, it updates the value.

Removing Elements

• remove(key: K): Removes the key-value pair associated with the specified key.

Accessing Elements

• get(key: K): Returns the value associated with the specified key, or null if the key is not found.
• keys: Returns a set of all keys in the map.
• values: Returns a collection of all values in the map.
• entries: Returns a set of all key-value pairs in the map.

Checking Size and Emptiness

• size: Returns the number of key-value pairs in the map.
• isEmpty(): Checks if the map is empty.
• isNotEmpty(): Checks if the map is not empty.

Clearing the Map

• clear(): Removes all key-value pairs from the map.

4. Examples of LinkedHashMap

Example 1: Adding Elements

put(key: K, value: V)

This example demonstrates how to add key-value pairs to the map.

fun main() {
    val map = LinkedHashMap<String, Int>()
    map["one"] = 1
    map["two"] = 2
    map.put("three", 3)
    println("Map after adding elements: $map") // Output: Map after adding elements: {one=1, two=2, three=3}
}

Output:

Map after adding elements: {one=1, two=2, three=3}

Example 2: Removing Elements

remove(key: K)

This example demonstrates how to remove a key-value pair from the map.

fun main() {
    val map = linkedMapOf("one" to 1, "two" to 2, "three" to 3)
    map.remove("two")
    println("Map after removing 'two': $map") // Output: Map after removing 'two': {one=1, three=3}
}

Output:

Map after removing 'two': {one=1, three=3}

Example 3: Accessing Elements

get(key: K)

This example demonstrates how to get the value associated with a specified key.

fun main() {
    val map = linkedMapOf("one" to 1, "two" to 2, "three" to 3)
    println("Value for key 'one': ${map["one"]}") // Output: Value for key 'one': 1
    println("Value for key 'four': ${map["four"]}") // Output: Value for key 'four': null
}

Output:

Value for key 'one': 1
Value for key 'four': null

keys, values, and entries

This example demonstrates how to access keys, values, and entries of the map.

fun main() {
    val map = linkedMapOf("one" to 1, "two" to 2, "three" to 3)
    println("Keys: ${map.keys}") // Output: Keys: [one, two, three]
    println("Values: ${map.values}") // Output: Values: [1, 2, 3]
    println("Entries: ${map.entries}") // Output: Entries: [one=1, two=2, three=3]
}

Output:

Keys: [one, two, three]
Values: [1, 2, 3]
Entries: [one=1, two=2, three=3]

Example 4: Checking Size and Emptiness

size, isEmpty(), and isNotEmpty()

This example demonstrates how to check the size of the map and if it is empty.

fun main() {
    val map = linkedMapOf("one" to 1, "two" to 2, "three" to 3)
    println("Size of map: ${map.size}") // Output: Size of map: 3
    println("Is map empty: ${map.isEmpty()}") // Output: Is map empty: false
    println("Is map not empty: ${map.isNotEmpty()}") // Output: Is map not empty: true
}

Output:

Size of map: 3
Is map empty: false
Is map not empty: true

Example 5: Clearing the Map

clear()

This example demonstrates how to remove all key-value pairs from the map.

fun main() {
    val map = linkedMapOf("one" to 1, "two" to 2, "three" to 3)
    map.clear()
    println("Map after clearing: $map") // Output: Map after clearing: {}
}

Output:

Map after clearing: {}

5. Real-World Use Case: Maintaining Insertion Order

LinkedHashMap can be used to maintain the order of elements based on their insertion order, which is useful for ordered data representation.

Example: Maintaining Insertion Order

fun main() {
    val map = LinkedHashMap<String, Int>()
    map["first"] = 1
    map["second"] = 2
    map["third"] = 3

    println("LinkedHashMap in insertion order:")
    for ((key, value) in map) {
        println("$key -> $value")
    }
}

Output:

LinkedHashMap in insertion order:
first -> 1
second -> 2
third -> 3

Explanation:
This example shows how LinkedHashMap maintains the insertion order of elements, which can be useful for ordered data representation.

Conclusion

LinkedHashMap in Kotlin is a versatile and efficient dynamic collection from the kotlin.collections package, ideal for scenarios requiring the maintenance of insertion order. Properly utilizing LinkedHashMap can greatly enhance the performance and flexibility of your applications.