Kotlin HashMap Class

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

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.

What is HashMap?
Creating a HashMap
Common Operations
Examples of HashMap
Real-World Use Case
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.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide