Why immutable collections are default in Kotlin - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create an immutable list in Kotlin.

Kotlin

val numbers = listOf[1](1, 2, 3, 4, 5)

Drag options to blanks, or click blank then click option'

A<Any>

B<Int>

C(nothing)

D<Number>

Attempts:

3 left

💡 Hint

Common Mistakes

Using mutableListOf instead of listOf

Adding parentheses incorrectly

In Kotlin, listOf creates an immutable list by default.

2fill in blank

medium

Complete the code to try adding an element to an immutable list and see the error.

Kotlin

val fruits = listOf("Apple", "Banana")
fruits.[1]("Cherry")

Drag options to blanks, or click blank then click option'

Aadd

Bappend

Cpush

Dinsert

Attempts:

3 left

💡 Hint

Common Mistakes

Using methods like append or push which don't exist in Kotlin lists

Trying to modify an immutable list directly

The add function is not available on immutable lists, so this code will cause an error.

3fill in blank

hard

Fix the error by choosing the correct mutable collection type to allow adding elements.

Kotlin

val fruits = [1]("Apple", "Banana")
fruits.add("Cherry")

Drag options to blanks, or click blank then click option'

AmutableListOf

BlistOf

CsetOf

DmapOf

Attempts:

3 left

💡 Hint

Common Mistakes

Using listOf which is immutable

Using setOf or mapOf which are different collection types

Using mutableListOf creates a list that can be changed, so add works.

4fill in blank

hard

Fill both blanks to create an immutable map and access a value safely.

Kotlin

val capitals = [1]("France" to "Paris", "Japan" to "Tokyo")
val capital = capitals.[2]("France")

Drag options to blanks, or click blank then click option'

AmapOf

Bget

CmutableMapOf

Dput

Attempts:

3 left

💡 Hint

Common Mistakes

Using mutableMapOf which creates a mutable map

Using put which adds or updates entries, not retrieves

mapOf creates an immutable map, and get retrieves a value by key.

5fill in blank

hard

Fill all three blanks to filter an immutable list and create a new list with only even numbers.

Kotlin

val numbers = listOf(1, 2, 3, 4, 5, 6)
val evens = numbers.[1] { it [2] 2 [3] 0 }

Drag options to blanks, or click blank then click option'

Afilter

B%

C==

Dmap

Attempts:

3 left

💡 Hint

Common Mistakes

Using map instead of filter which transforms elements

Using incorrect comparison operators

filter creates a new list with elements matching the condition. The condition checks if the number modulo 2 equals 0, meaning it's even.

Practice

1. Why does Kotlin use immutable collections as the default choice?

easy

A. Because they prevent accidental changes and make code safer

B. Because they are faster to create than mutable collections

C. Because they allow adding elements after creation

D. Because they use less memory than mutable collections

Solution

1. Step 1: Understand immutability concept

   Immutable collections cannot be changed after creation, preventing accidental modifications.

2. Step 2: Recognize safety benefits

   This immutability makes programs safer and easier to understand by avoiding unexpected side effects.

3. Final Answer:

   Because they prevent accidental changes and make code safer -> Option A

4. Quick Check:

   Immutable collections = safer code [OK]

Hint: Immutable means no changes allowed after creation [OK]

Common Mistakes:

• Thinking immutable collections allow adding elements
• Assuming immutable collections are always faster
• Confusing immutability with memory usage

2. Which of the following is the correct way to create an immutable list in Kotlin?

easy

A. val list = ArrayList(1, 2, 3)

B. val list = mutableListOf(1, 2, 3)

C. val list = arrayListOf(1, 2, 3)

D. val list = listOf(1, 2, 3)

Solution

1. Step 1: Identify immutable list creation function

   In Kotlin, listOf() creates an immutable list.

2. Step 2: Differentiate from mutable list functions

   mutableListOf(), arrayListOf(), and ArrayList() create mutable lists.

3. Final Answer:

   val list = listOf(1, 2, 3) -> Option D

4. Quick Check:

   Immutable list = listOf() [OK]

Hint: Use listOf() for immutable lists in Kotlin [OK]

Common Mistakes:

• Using mutableListOf() when immutable is needed
• Confusing arrayListOf() with immutable listOf()
• Trying to use ArrayList constructor with elements directly

3. What will be the output of this Kotlin code?

val numbers = listOf(1, 2, 3)
numbers.add(4)

medium

A. List will contain [1, 2, 3, 4]

B. Compilation error: Unresolved reference 'add'

C. Runtime error: UnsupportedOperationException

D. List remains [1, 2, 3] without error

Solution

1. Step 1: Recognize listOf creates immutable list

   The listOf() function returns an immutable list that does not support modification methods like add().

2. Step 2: Understand behavior of calling add() on immutable list

   Calling add() on a List<T> causes a compilation error because List<T> has no add() method: Unresolved reference 'add'.

3. Final Answer:

   Compilation error: Unresolved reference 'add' -> Option B

4. Quick Check:

   Immutable list + add() = compile error [OK]

Hint: Immutable lists have no add() method: compile error [OK]

Common Mistakes:

• Expecting runtime error instead of compile-time error
• Assuming add() works on immutable lists
• Thinking list remains unchanged silently

4. Identify the error in this Kotlin code snippet:

val set = setOf(1, 2, 3)
set.add(4)

medium

A. Runtime error: UnsupportedOperationException when calling add()

B. Syntax error: setOf cannot be used without mutable keyword

C. Compile-time error: add() is not a function of Set

D. No error, set will contain 4 elements

Solution

1. Step 1: Understand setOf creates immutable set

   The setOf() function returns an immutable set that does not support modification.

2. Step 2: Analyze calling add() on immutable set

   Calling add() on a Set<T> causes a compile-time error because Set<T> has no add() method.

3. Final Answer:

   Compile-time error: add() is not a function of Set -> Option C

4. Quick Check:

   Immutable set + add() = compile error [OK]

Hint: Immutable sets have no add() method: compile error [OK]

Common Mistakes:

• Expecting runtime error instead of compile-time error
• Assuming setOf creates mutable sets
• Thinking add() silently fails without error

5. You want to create a map in Kotlin that cannot be changed after creation. Which approach correctly ensures immutability and prevents accidental modification?

hard

A. Use mapOf() to create an immutable map

B. Use mutableMapOf() and avoid calling modification methods

C. Create a mutable map and then assign it to a val variable

D. Use HashMap() and do not expose it outside the function

Solution

1. Step 1: Identify immutable map creation method

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

2. Step 2: Understand why other options fail

   Using mutableMapOf() or HashMap() creates mutable maps; assigning to val only prevents reassignment, not modification.

3. Final Answer:

   Use mapOf() to create an immutable map -> Option A

4. Quick Check:

   Immutable map = mapOf() [OK]

Hint: Use mapOf() for truly immutable maps in Kotlin [OK]

Common Mistakes:

• Thinking val prevents map modification
• Using mutableMapOf() expecting immutability
• Relying on scope to protect mutable maps