Why immutable collections are default in Kotlin - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of modifying a Kotlin immutable list

What is the output of this Kotlin code snippet?

Kotlin

val list = listOf(1, 2, 3)
val newList = list.plus(4)
println(list)
println(newList)

A Compilation error

B

[1, 2, 3, 4]
[1, 2, 3, 4]

C

[1, 2, 3]
[1, 2, 3]

D

[1, 2, 3]
[1, 2, 3, 4]

💡 Hint

Remember that listOf creates an immutable list and plus returns a new list.

The original list is immutable and does not change. The plus function returns a new list with the added element. So the first print shows the original list, and the second print shows the new list.

🧠 Conceptual

intermediate

Reason for default immutability in Kotlin collections

Why does Kotlin make collections immutable by default?

A To prevent accidental changes and improve thread safety

B Because mutable collections are deprecated

C To make collections slower but safer

D Because Kotlin does not support mutable collections

💡 Hint

Think about safety and bugs in programs.

Immutable collections prevent accidental changes, which reduces bugs and makes programs easier to reason about. They also improve thread safety because no one can change the data unexpectedly.

🔧 Debug

advanced

Identify the error when modifying an immutable list

What error does this Kotlin code produce?

Kotlin

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

A UnsupportedOperationException at runtime

B Unresolved reference: add

C Compilation error: val cannot be reassigned

D No error, list is modified

💡 Hint

Check if immutable lists have an add method.

Immutable lists do not have an add method. Trying to call add causes a compilation error because the method does not exist.

❓ Predict Output

advanced

Output of modifying a mutable list

What is the output of this Kotlin code?

Kotlin

val mutableList = mutableListOf(1, 2, 3)
mutableList.add(4)
println(mutableList)

A Compilation error

B [1, 2, 3]

C [1, 2, 3, 4]

D Runtime exception

💡 Hint

Mutable lists allow adding elements.

Mutable lists can be changed. The add method adds 4 to the list, so the print shows the updated list.

🧠 Conceptual

expert

Why prefer immutable collections in concurrent programming?

Why are immutable collections preferred in concurrent programming?

A Because they avoid synchronization issues by not allowing changes

B Because they allow multiple threads to write safely at the same time

C Because they are faster to modify than mutable collections

D Because they automatically lock data for each thread

💡 Hint

Think about what happens if many threads try to change data at once.

Immutable collections cannot be changed, so multiple threads can read them safely without locks or synchronization. This avoids common concurrency bugs.