Map creation (mapOf, mutableMapOf) in Kotlin

Introduction

Maps help you store pairs of related information, like a name and a phone number. Using mapOf and mutableMapOf lets you create these pairs easily.

When you want to look up a value by a key, like finding a phone number by a person's name.

When you need to store settings or options with names and values.

When you want to group data where each item has a unique label.

When you want to change or add pairs after creating the map, use a mutable map.

When you only need to read data without changing it, use an immutable map.

Syntax

Kotlin

val mapName = mapOf(key1 to value1, key2 to value2)
val mutableMapName = mutableMapOf(key1 to value1, key2 to value2)

mapOf creates a map you cannot change later (immutable).

mutableMapOf creates a map you can add or remove pairs from (mutable).

Examples

This creates an immutable map of color names to their hex codes.

Kotlin

val colors = mapOf("red" to "#FF0000", "green" to "#00FF00")

This creates a mutable map with user information you can update later.

Kotlin

val userInfo = mutableMapOf("name" to "Alice", "age" to 30)

Updates the age in the mutable map to 31.

Kotlin

userInfo["age"] = 31

Sample Program

This program shows how to create an immutable map of country capitals and a mutable map of game scores. It prints the capital of France, then shows the scores before and after updating.

Kotlin

fun main() {
    val capitals = mapOf("France" to "Paris", "Japan" to "Tokyo")
    println("Capital of France: ${capitals["France"]}")

    val scores = mutableMapOf("Alice" to 10, "Bob" to 8)
    println("Initial scores: $scores")

    scores["Alice"] = 15
    scores["Charlie"] = 12
    println("Updated scores: $scores")
}

Important Notes

Immutable maps cannot be changed after creation; trying to add or remove items will cause an error.

Mutable maps let you add, update, or remove pairs anytime.

Use the to keyword to create pairs inside the map.

Summary

mapOf creates a fixed map you cannot change.

mutableMapOf creates a map you can change later.

Maps store pairs of keys and values for easy lookup.

Practice

1. What does mapOf create in Kotlin?

easy

A. A list of values without keys

B. A mutable map that can be changed later

C. A fixed map that cannot be changed after creation

D. An empty map with no keys or values

Solution

1. Step 1: Understand mapOf purpose

   mapOf creates a map with key-value pairs that cannot be modified after creation.

2. Step 2: Compare with other map types

   mutableMapOf allows changes, but mapOf does not.

3. Final Answer:

   A fixed map that cannot be changed after creation -> Option C

4. Quick Check:

   mapOf = fixed map [OK]

Hint: Remember: mapOf = fixed map, mutableMapOf = changeable map [OK]

Common Mistakes:

• Confusing mapOf with mutableMapOf
• Thinking mapOf creates an empty map
• Assuming mapOf allows adding new entries

2. Which of the following is the correct syntax to create a mutable map with keys "a" and "b" and values 1 and 2 respectively?

easy

A. val map = mutableMapOf("a" to 1, "b" to 2)

B. val map = mapOf("a" -> 1, "b" -> 2)

C. val map = mutableMapOf("a" = 1, "b" = 2)

D. val map = mapOf("a" to 1, "b" to 2)

Solution

1. Step 1: Identify correct syntax for mutableMapOf

   The correct syntax uses mutableMapOf with pairs using to keyword.

2. Step 2: Check each option

   val map = mutableMapOf("a" to 1, "b" to 2) uses mutableMapOf and to correctly. val map = mapOf("a" -> 1, "b" -> 2) uses wrong arrow ->. val map = mutableMapOf("a" = 1, "b" = 2) uses = which is invalid here. val map = mapOf("a" to 1, "b" to 2) uses mapOf which creates an immutable map.

3. Final Answer:

   val map = mutableMapOf("a" to 1, "b" to 2) -> Option A

4. Quick Check:

   mutableMapOf + to = correct syntax [OK]

Hint: Use mutableMapOf with "key" to value pairs [OK]

Common Mistakes:

• Using -> instead of to for pairs
• Using = inside mapOf or mutableMapOf
• Confusing mapOf and mutableMapOf

3. What is the output of this Kotlin code?

val map = mapOf("x" to 10, "y" to 20)
println(map["x"])
println(map["z"])

medium

A. 20
null

B. 10
null

C. null
null

D. 10
0

Solution

1. Step 1: Access existing key "x"

   map["x"] returns 10 because "x" is a key with value 10.

2. Step 2: Access non-existing key "z"

   map["z"] returns null because "z" is not in the map.

3. Final Answer:

   10\nnull -> Option B

4. Quick Check:

   Existing key returns value, missing key returns null [OK]

Hint: map[key] returns value or null if key missing [OK]

Common Mistakes:

• Expecting 0 instead of null for missing key
• Confusing values of different keys
• Assuming map is mutable and can add keys

4. What is wrong with this Kotlin code?

val map = mapOf("a" to 1)
map["b"] = 2

medium

A. mapOf creates an immutable map, so you cannot add new entries

B. The syntax for adding entries is incorrect; should use put()

C. Keys must be integers, not strings

D. mapOf requires mutableMapOf to add entries

Solution

1. Step 1: Understand mapOf immutability

   mapOf creates an immutable map that cannot be changed after creation.

2. Step 2: Adding entries to immutable map causes error

   Trying to assign a new key-value pair with map["b"] = 2 causes a compile-time error because the map is immutable.

3. Final Answer:

   mapOf creates an immutable map, so you cannot add new entries -> Option A

4. Quick Check:

   Immutable map cannot be changed [OK]

Hint: Use mutableMapOf to add or change entries [OK]

Common Mistakes:

• Trying to add entries to mapOf
• Using wrong syntax for adding entries
• Confusing mutableMapOf and mapOf

5. You want to create a map that stores student names as keys and their scores as values. You also want to update scores later. Which Kotlin code snippet correctly achieves this?

hard

A. val scores = mutableMapOf("Alice" to 90, "Bob" to 85)
scores.add("Alice", 95)

B. val scores = mapOf("Alice" to 90, "Bob" to 85)
scores["Alice"] = 95

C. val scores = mapOf("Alice" to 90, "Bob" to 85)
scores.put("Alice", 95)

D. val scores = mutableMapOf("Alice" to 90, "Bob" to 85)
scores["Alice"] = 95

Solution

1. Step 1: Choose a mutable map to allow updates

   Since scores need to be updated, mutableMapOf is required.

2. Step 2: Use correct method to update value

   Assigning with scores["Alice"] = 95 correctly updates the value in a mutable map.

3. Step 3: Check other options for errors

   val scores = mapOf("Alice" to 90, "Bob" to 85) scores["Alice"] = 95 uses immutable map and tries to update, causing error. val scores = mapOf("Alice" to 90, "Bob" to 85) scores.put("Alice", 95) tries to use put on immutable map, error. val scores = mutableMapOf("Alice" to 90, "Bob" to 85) scores.add("Alice", 95) uses non-existent add method.

4. Final Answer:

   val scores = mutableMapOf("Alice" to 90, "Bob" to 85) scores["Alice"] = 95 -> Option D

5. Quick Check:

   mutableMapOf + assignment updates map [OK]

Hint: Use mutableMapOf and bracket assignment to update entries [OK]

Common Mistakes:

• Using mapOf when updates are needed
• Trying to use put on immutable map
• Using add method which does not exist