Kotlin HashMap Class

Introduction

In Kotlin, HashMap is a hash table-based implementation of the MutableMap interface. It provides a collection of key-value pairs, where each key is unique. HashMap is part of the kotlin.collections package and is used for storing and managing data with efficient access, insertion, and deletion operations.

Table of Contents

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

1. What is HashMap?

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

2. Creating a HashMap

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

Example

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

3. Common Operations

HashMap 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 HashMap

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 = HashMap<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 = hashMapOf("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 = hashMapOf("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 = hashMapOf("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 = hashMapOf("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 = hashMapOf("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: Counting Word Frequencies

You can use HashMap to count the frequency of words in a list.

Example: Counting Word Frequencies

fun main() {
    val words = listOf("apple", "banana", "apple", "orange", "banana", "apple")
    val wordCount = HashMap<String, Int>()

    for (word in words) {
        val count = wordCount[word] ?: 0
        wordCount[word] = count + 1
    }

    println("Word frequencies: $wordCount")
}

Output:

Word frequencies: {apple=3, banana=2, orange=1}

Explanation:
This example counts the frequency of each word in a list and stores the results in a HashMap.

Conclusion

HashMap in Kotlin is a versatile and efficient dynamic collection from the kotlin.collections package, ideal for scenarios requiring frequent modifications to the key-value pairs. Properly utilizing HashMap can greatly enhance the performance and flexibility of your applications.