Mutable vs immutable interfaces in Kotlin - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of modifying a mutable list via interface

What is the output of this Kotlin code snippet?

Kotlin

val list: MutableList<Int> = mutableListOf(1, 2, 3)
val readOnlyList: List<Int> = list
list.add(4)
println(readOnlyList.size)

A 4

B 3

C Compilation error

D Runtime exception

💡 Hint

Think about whether the readOnlyList reflects changes to the original mutable list.

The readOnlyList is a reference to the same mutable list. Adding an element to the mutable list changes its size, so readOnlyList.size is 4.

🧠 Conceptual

intermediate

Difference between MutableList and List interfaces

Which statement correctly describes the difference between Kotlin's MutableList and List interfaces?

A MutableList allows modification of elements, List does not allow any modification.

B List allows modification of elements, MutableList does not.

C Both MutableList and List allow modification but MutableList has extra methods.

D Neither MutableList nor List allow modification of elements.

💡 Hint

Consider which interface provides methods like add, remove, or clear.

MutableList extends List and adds methods to modify the collection. List only provides read-only access.

❓ Predict Output

advanced

Output when casting mutable to immutable and modifying

What is the output of this Kotlin code?

Kotlin

val mutable: MutableList<String> = mutableListOf("a", "b")
val immutable: List<String> = mutable
(mutable as MutableList<String>).add("c")
println(immutable.size)

A 2

B Compilation error

C ClassCastException

D 3

💡 Hint

Remember that immutable is just a reference to the same mutable list.

The immutable variable points to the same mutable list. Adding "c" increases the size to 3, so printing immutable.size outputs 3.

❓ Predict Output

advanced

Error when trying to modify an immutable list

What error does this Kotlin code produce?

Kotlin

val list: List<Int> = 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 becomes [1, 2, 3, 4]

💡 Hint

Check if List interface has an add method.

The List interface in Kotlin does not have an add method, so calling list.add(4) causes a compilation error: Unresolved reference: add.

🧠 Conceptual

expert

Why prefer immutable interfaces in API design?

Which is the best reason to expose immutable interfaces (like List) instead of mutable ones (like MutableList) in Kotlin API design?

A To improve performance by disabling modifications

B Because immutable interfaces have more methods

C To prevent clients from modifying internal data accidentally

D To allow clients to add elements safely

💡 Hint

Think about controlling how data is changed by users of your API.

Exposing immutable interfaces prevents clients from changing internal data, which helps maintain data integrity and reduces bugs.