Kotlin - 31 - Mutable Maps in Kotlin

In Kotlin, a mutable map is a collection that allows you to add, remove, and modify key-value pairs. Mutable maps are used when you need to work with data that is associated with unique keys and can change over time. In this article, we will explore mutable maps in Kotlin, how to create them, manipulate their key-value pairs, and perform common map operations.

Creating Mutable Maps

You can create mutable maps in Kotlin using the mutableMapOf() function. This function initializes an empty mutable map or populates it with initial key-value pairs. Here’s an example of creating a mutable map of strings to integers:


val mutableFruitsCount: MutableMap<String, Int> = mutableMapOf(
    "apple" to 5,
    "banana" to 3,
    "cherry" to 8
)

In this example, mutableFruitsCount is a mutable map containing three key-value pairs, with fruit names as keys and their respective counts as values. You can add, remove, or modify these key-value pairs as needed.

Adding Key-Value Pairs

To add key-value pairs to a mutable map, you can use the [] operator or the put() method. Here’s an example:


mutableFruitsCount["date"] = 6 // Adding a new key-value pair
mutableFruitsCount.put("blueberry", 10) // Adding another key-value pair

After executing this code, the mutableFruitsCount map will contain two new key-value pairs: “date” with a value of 6 and “blueberry” with a value of 10.

Updating Values

You can update the values associated with existing keys in a mutable map by assigning new values to those keys. Here’s an example:


mutableFruitsCount["apple"] = 7 // Updating the value for an existing key

This code changes the value associated with the “apple” key from 5 to 7 in the mutableFruitsCount map.

Removing Key-Value Pairs

To remove key-value pairs from a mutable map, you can use the remove() method. This method removes a key-value pair by its key. Here’s an example:


mutableFruitsCount.remove("banana") // Removing a key-value pair by key

After executing this command, the key-value pair with the key “banana” will be removed from the mutableFruitsCount map.

Iterating Over Mutable Maps

You can iterate over the key-value pairs of a mutable map in Kotlin using a for loop or the forEach() function. Here’s a for loop example:


for ((fruit, count) in mutableFruitsCount) {
    println("$fruit: $count")
}

You can also use the forEach() function to perform actions on each key-value pair:


mutableFruitsCount.forEach { (fruit, count) ->
    println("$fruit: $count")
}

Common Map Operations

Mutable maps in Kotlin support various common operations, including:

size: Returns the number of key-value pairs in the map.
isEmpty(): Checks if the map is empty.
containsKey(): Checks if the map contains a specific key.
containsValue(): Checks if the map contains a specific value.
keys: Returns a set of all keys in the map.
values: Returns a collection of all values in the map.

Here’s an example demonstrating some of these operations:


val mapSize = mutableFruitsCount.size
val isEmpty = mutableFruitsCount.isEmpty()
val hasApple = mutableFruitsCount.containsKey("apple")
val hasValue8 = mutableFruitsCount.containsValue(8)
val mapKeys = mutableFruitsCount.keys
val mapValues = mutableFruitsCount.values

These operations allow you to manipulate and query mutable maps effectively.

Conclusion

Mutable maps in Kotlin provide a versatile way to manage and manipulate key-value pairs that can change over time. They enable you to add, remove, and update key-value pairs as well as perform common map operations. Understanding how to work with mutable maps is essential for building dynamic and flexible Kotlin applications.

Kotlin – 31 – Mutable Maps in Kotlin