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.

Practice

1. Which statement best describes the difference between mutable and immutable interfaces in Kotlin?

easy

A. Immutable interfaces are used only for primitive types.

B. Mutable interfaces only allow reading data, immutable interfaces allow modification.

C. Both mutable and immutable interfaces allow data modification.

D. Immutable interfaces allow only reading data, while mutable interfaces allow data modification.

Solution

1. Step 1: Understand interface roles

   Immutable interfaces provide read-only access to data, preventing changes.

2. Step 2: Compare mutable interfaces

   Mutable interfaces extend immutable ones and allow data to be changed.

3. Final Answer:

   Immutable interfaces allow only reading data, while mutable interfaces allow data modification. -> Option D

4. Quick Check:

   Immutable = read-only, Mutable = read-write [OK]

Hint: Immutable = read-only, mutable = can change data [OK]

Common Mistakes:

• Confusing which interface allows modification
• Thinking both interfaces allow changes
• Assuming immutable interfaces are only for primitives

2. Which of the following is the correct way to declare a mutable list interface in Kotlin?

easy

A. val list: MutableList<Int> = listOf(1, 2, 3)

B. val list: List<Int> = mutableListOf(1, 2, 3)

C. val list: MutableList<Int> = mutableListOf(1, 2, 3)

D. val list: List<Int> = listOf(1, 2, 3)

Solution

1. Step 1: Identify mutable list declaration

   MutableList is the interface for mutable lists, and mutableListOf() creates a mutable list instance.

2. Step 2: Check each option

   val list: MutableList<Int> = mutableListOf(1, 2, 3) correctly declares a MutableList and initializes it with mutableListOf().

3. Final Answer:

   val list: MutableList<Int> = mutableListOf(1, 2, 3) -> Option C

4. Quick Check:

   MutableList + mutableListOf() = mutable list [OK]

Hint: Use MutableList with mutableListOf() for mutable lists [OK]

Common Mistakes:

• Using listOf() with MutableList type
• Declaring mutable list as List type
• Mixing mutable and immutable functions

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

val immutableList: List<Int> = listOf(1, 2, 3)
val mutableList: MutableList<Int> = mutableListOf(4, 5, 6)

println(immutableList.size)
mutableList.add(7)
println(mutableList)

medium

A. 3
[4, 5, 6, 7]

B. 3
[4, 5, 6]

C. 4
[4, 5, 6, 7]

D. Compilation error

Solution

1. Step 1: Check immutable list size

   immutableList has 3 elements, so size is 3.

2. Step 2: Add element to mutable list and print

   mutableList adds 7, so it becomes [4, 5, 6, 7].

3. Final Answer:

   3 [4, 5, 6, 7] -> Option A

4. Quick Check:

   Immutable size 3, mutable list adds 7 [OK]

Hint: Immutable size fixed; mutable can add elements [OK]

Common Mistakes:

• Trying to add to immutable list causing error
• Expecting immutable list size to change
• Confusing output format

4. Identify the error in this Kotlin code snippet:

val numbers: List<Int> = listOf(1, 2, 3)
numbers.add(4)

medium

A. Cannot add to a List because it is immutable

B. Syntax error in listOf() usage

C. No error, code runs fine

D. Variable numbers should be declared as var

Solution

1. Step 1: Understand List immutability

   List interface in Kotlin is immutable; it does not support add() method.

2. Step 2: Analyze the error

   Calling add(4) on immutable List causes a compilation error.

3. Final Answer:

   Cannot add to a List because it is immutable -> Option A

4. Quick Check:

   Immutable List blocks add() method [OK]

Hint: List is immutable; use MutableList to add elements [OK]

Common Mistakes:

• Trying to add to immutable List
• Assuming var allows modification of immutable List
• Confusing syntax error with immutability error

5. You have a function that accepts a List<String> parameter but you want to modify the list inside the function. Which is the best approach to handle this in Kotlin?

hard

A. Change the parameter type to MutableList<String> and pass a mutable list.

B. Create a new mutable copy of the list inside the function and modify that.

C. Use val keyword inside the function to modify the list.

D. Keep the parameter as List<String> and cast it to MutableList inside the function.

Solution

1. Step 1: Understand parameter immutability

   List<String> is immutable, so it cannot be modified directly.

2. Step 2: Evaluate safe modification methods

   Casting to MutableList is unsafe and may cause runtime errors; changing parameter type affects API design.

3. Step 3: Use safe copy for modification

   Creating a mutable copy inside the function allows safe modifications without affecting original list.

4. Final Answer:

   Create a new mutable copy of the list inside the function and modify that. -> Option B

5. Quick Check:

   Copy immutable list to mutable for safe changes [OK]

Hint: Copy immutable list to mutable before modifying [OK]

Common Mistakes:

• Casting immutable list to mutable unsafely
• Changing parameter type breaking API contracts
• Assuming val allows modification