Map creation (mapOf, mutableMapOf) in Kotlin - Step-by-Step Execution

Concept Flow - Map creation (mapOf, mutableMapOf)

Start

↓

Choose map type

↓

Create read-only map

↓

Create changeable map

↓

Add key-value pairs

↓

Use map

↓

End

You start by choosing which map to create: an immutable map with mapOf or a mutable map with mutableMapOf. Then you add key-value pairs and use the map.

Execution Sample

Kotlin

val readOnlyMap = mapOf("a" to 1, "b" to 2)
val changeableMap = mutableMapOf("x" to 10)
changeableMap["y"] = 20
println(readOnlyMap)
println(changeableMap)

Creates an immutable map and a mutable map, adds a new pair to the mutable map, then prints both.

Execution Table

Step	Action	Map State	Output
1	Create readOnlyMap with pairs ("a" to 1, "b" to 2)	{"a"=1, "b"=2}
2	Create changeableMap with pair ("x" to 10)	{"x"=10}
3	Add pair ("y" to 20) to changeableMap	{"x"=10, "y"=20}
4	Print readOnlyMap	{"a"=1, "b"=2}	{a=1, b=2}
5	Print changeableMap	{"x"=10, "y"=20}	{x=10, y=20}

💡 All steps completed, maps created and printed.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
readOnlyMap	empty	{"a"=1, "b"=2}	{"a"=1, "b"=2}	{"a"=1, "b"=2}	{"a"=1, "b"=2}
changeableMap	empty	empty	{"x"=10}	{"x"=10, "y"=20}	{"x"=10, "y"=20}

Key Moments - 2 Insights

Why can't we add new pairs to readOnlyMap after creation?

Because readOnlyMap is created with mapOf which makes an immutable map. The execution_table shows no step where readOnlyMap changes after creation.

How do we add a new key-value pair to changeableMap?

We use the syntax changeableMap["key"] = value as shown in step 3 of the execution_table, which updates the map.

Visual Quiz - 3 Questions

Look at the execution_table, what is the content of changeableMap after step 2?

A {"x"=10}

B {"y"=20}

C {"x"=10, "y"=20}

D {}

💡 Hint

Check the 'Map State' column at step 2 in the execution_table.

At which step does changeableMap get a new key-value pair added?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look for the step where changeableMap changes from {"x"=10} to {"x"=10, "y"=20}.

If we tried to add a new pair to readOnlyMap after step 1, what would happen?

A It would add the pair successfully.

B It would silently ignore the addition.

C It would cause a compile-time error.

D It would remove an existing pair.

💡 Hint

Recall that mapOf creates an immutable map as shown in the key_moments section.

Concept Snapshot

mapOf creates an immutable (read-only) map.
mutableMapOf creates a mutable (changeable) map.
Add pairs at creation or use [key] = value for mutable maps.
Immutable maps cannot be changed after creation.
Use mutable maps when you need to add or remove entries.

Full Transcript

This example shows how to create maps in Kotlin using mapOf and mutableMapOf. mapOf creates a read-only map that cannot be changed after creation. mutableMapOf creates a map that you can add or change entries in. We create readOnlyMap with two pairs and changeableMap with one pair. Then we add a new pair to changeableMap. Finally, we print both maps to see their contents. The execution table traces each step, showing how the maps change or stay the same. The variable tracker shows the state of each map after each step. Key moments explain why immutable maps cannot be changed and how to add pairs to mutable maps. The quiz tests understanding of these steps and concepts.

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