Mutable vs immutable interfaces in Kotlin - Visual Side-by-Side Comparison

Concept Flow - Mutable vs immutable interfaces

Start with collection reference

↓

Is interface mutable?

No→Immutable: no change allowed

Yes↓

Mutable: can add, remove, update

↓

Use collection methods accordingly

↓

End

This flow shows how a collection reference can be either mutable or immutable, affecting what operations are allowed.

Execution Sample

Kotlin

val list: List<Int> = listOf(1, 2, 3)
val mutableList: MutableList<Int> = mutableListOf(1, 2, 3)

// list.add(4) // Error
mutableList.add(4)
println(mutableList)

This code shows an immutable list that cannot be changed and a mutable list that can be updated.

Execution Table

Step	Code Line	Action	Result	Output
1	val list: List<Int> = listOf(1, 2, 3)	Create immutable list	list = [1, 2, 3]
2	val mutableList: MutableList<Int> = mutableListOf(1, 2, 3)	Create mutable list	mutableList = [1, 2, 3]
3	// list.add(4) // Error	Attempt to add to immutable list	Compile error: Unresolved reference: add
4	mutableList.add(4)	Add 4 to mutableList	mutableList = [1, 2, 3, 4]
5	println(mutableList)	Print mutableList		[1, 2, 3, 4]

💡 Execution stops after printing the updated mutable list; adding to immutable list is not allowed.

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
list	undefined	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]
mutableList	undefined	[1, 2, 3]	[1, 2, 3, 4]	[1, 2, 3, 4]

Key Moments - 2 Insights

Why can't we add an element to 'list'?

'list' is declared as List<Int>, which is immutable. The execution_table row 3 shows a compile error when trying to add.

What happens when we add an element to 'mutableList'?

Since 'mutableList' is MutableList<Int>, it allows adding elements. Row 4 shows the list updated with the new element.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what happens when trying to add to 'list'?

A Compile error occurs

B The element is added successfully

C Nothing happens, code skips

D Runtime exception occurs

💡 Hint

Check execution_table row 3 under 'Result' for the error message.

At which step does 'mutableList' change its contents?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at variable_tracker for 'mutableList' changes after each step.

If 'list' was declared as MutableList<Int>, what would happen at step 3?

A Compile error still occurs

B Runtime exception occurs

C Element would be added successfully

D Code would skip adding

💡 Hint

Refer to the difference between List and MutableList in the concept_flow and execution_table.

Concept Snapshot

Mutable vs Immutable Interfaces in Kotlin:
- List<T> is immutable: no add/remove/update allowed.
- MutableList<T> is mutable: supports add, remove, update.
- Immutable interfaces prevent accidental changes.
- Use mutable interfaces when you need to change collections.
- Trying to modify immutable collections causes compile errors.

Full Transcript

This lesson shows the difference between mutable and immutable interfaces in Kotlin using lists. An immutable list (List<Int>) cannot be changed after creation, so trying to add elements causes a compile error. A mutable list (MutableList<Int>) allows adding, removing, and updating elements. The execution table traces each step: creating lists, attempting to add to immutable list (which fails), adding to mutable list (which succeeds), and printing the result. The variable tracker shows how the lists' contents change over time. Key moments clarify why immutable lists cannot be changed and how mutable lists work. The quiz tests understanding of these concepts by referencing the execution steps. Remember: use immutable interfaces for safety and mutable interfaces when changes are needed.