Collections interop behavior in Kotlin - Step-by-Step Execution

Concept Flow - Collections interop behavior

Start with Kotlin Collection

↓

Pass to Java Method

↓

Java sees Collection as Java Collection

↓

Java modifies or reads Collection

↓

Back to Kotlin with updated Collection

↓

Kotlin uses Collection with Java changes

Shows how Kotlin collections are passed to Java and seen as Java collections, then changes flow back to Kotlin.

Execution Sample

Kotlin

fun main() {
    val list = mutableListOf("a", "b")
    JavaInterop.modifyList(list)
    println(list)
}

Kotlin mutable list passed to Java method which modifies it, then Kotlin prints updated list.

Execution Table

Step	Action	Kotlin list content	Java view	Output
1	Create Kotlin mutableListOf("a", "b")	["a", "b"]	N/A	N/A
2	Pass list to JavaInterop.modifyList	["a", "b"]	Java List with ["a", "b"]	N/A
3	JavaInterop adds "c" to list	["a", "b", "c"]	Java List after add: ["a", "b", "c"]	N/A
4	Return to Kotlin	["a", "b", "c"]	N/A	N/A
5	Print list in Kotlin	["a", "b", "c"]	N/A	[a, b, c]
6	End	["a", "b", "c"]	N/A	N/A

💡 Java modifies the Kotlin list, changes visible back in Kotlin, then program ends.

Variable Tracker

Variable	Start	After Java modifies	Final
list	["a", "b"]	["a", "b", "c"]	["a", "b", "c"]

Key Moments - 2 Insights

Why does the Kotlin list show the new element added by Java?

Because Kotlin mutableListOf returns a mutable list that Java sees as a normal Java List, so changes in Java affect the same object Kotlin uses (see execution_table step 3 and 4).

Does Kotlin copy the list when passing to Java?

No, Kotlin passes the actual list object to Java, so both share the same collection instance (execution_table step 2).

Visual Quiz - 3 Questions

Look at the execution_table, what is the content of the list after JavaInterop.modifyList adds an element?

A ["a", "b", "c"]

B ["a", "b"]

C ["c"]

D []

💡 Hint

Check execution_table row 3 under Kotlin list content.

At which step does Kotlin print the updated list?

A Step 2

B Step 5

C Step 3

D Step 1

💡 Hint

Look at execution_table row 5 under Action and Output.

If Kotlin passed an immutable list to Java, what would happen to the list content after Java tries to add an element?

A Kotlin would throw an error immediately

B The list would have the new element added

C The list would remain unchanged in Kotlin

D Java would receive a copy and modify only that

💡 Hint

Think about mutability and shared references shown in variable_tracker.

Concept Snapshot

Kotlin collections passed to Java are seen as Java collections.
Mutable Kotlin collections can be changed by Java code.
Changes in Java reflect back in Kotlin because they share the same object.
Immutable Kotlin collections prevent Java from modifying them.
Interop uses shared references, not copies.

Full Transcript

This example shows how Kotlin collections behave when passed to Java code. A Kotlin mutable list is created with two elements. This list is passed to a Java method that adds a new element. Because Kotlin mutable lists are seen as Java lists, the Java method modifies the same list object. When control returns to Kotlin, the list now contains the new element added by Java. Printing the list in Kotlin shows all three elements. This demonstrates that Kotlin and Java share the same collection instance during interop, so changes in one language are visible in the other. If the Kotlin list were immutable, Java could not modify it. This behavior is important to understand when mixing Kotlin and Java code.

Practice

1. In Kotlin, when you use a Java List inside Kotlin code, what happens to the collection?

easy

A. Kotlin wraps the Java list directly without copying it.

B. Kotlin creates a new copy of the Java list.

C. Kotlin converts the Java list to a Kotlin Set.

D. Kotlin throws an error because Java collections are incompatible.

Solution

1. Step 1: Understand Kotlin-Java collection interop

   Kotlin collections can wrap Java collections directly, meaning no new copy is made.

2. Step 2: Identify behavior for Java List in Kotlin

   Using a Java List in Kotlin results in a wrapper around the original Java list, preserving changes.

3. Final Answer:

   Kotlin wraps the Java list directly without copying it. -> Option A

4. Quick Check:

   Kotlin wraps Java collections directly = D [OK]

Hint: Kotlin wraps Java collections directly, no copying needed [OK]

Common Mistakes:

• Thinking Kotlin copies Java collections
• Assuming Java collections convert to Kotlin sets
• Believing Java collections cause errors in Kotlin

2. Which of the following Kotlin code snippets correctly creates a mutable Kotlin list from a Java ArrayList without copying?

easy

A. val javaList = ArrayList<String>(); val kotlinList = javaList as MutableList<String>

B. val javaList = ArrayList<String>(); val kotlinList = javaList.toMutableList()

C. val javaList = ArrayList<String>(); val kotlinList = javaList.toList()

D. val javaList = ArrayList<String>(); val kotlinList = javaList.copy()

Solution

1. Step 1: Review Kotlin-Java mutable list interop

   Kotlin mutable lists can be created by casting Java mutable lists directly without copying.

2. Step 2: Analyze each option

   val javaList = ArrayList<String>(); val kotlinList = javaList as MutableList<String> uses as MutableList<String> to wrap the Java ArrayList directly. toList() and toMutableList() create copies, and there is no copy() method.

3. Final Answer:

   val javaList = ArrayList<String>(); val kotlinList = javaList as MutableList<String> -> Option A

4. Quick Check:

   Cast Java list to MutableList for no copy = C [OK]

Hint: Cast Java list to MutableList to avoid copying [OK]

Common Mistakes:

• Using toList() or toMutableList() which copies
• Trying to call non-existent copy() method
• Not casting and expecting automatic conversion

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

val javaList = java.util.ArrayList<String>()
javaList.add("Kotlin")
val kotlinList: List<String> = javaList
println(kotlinList[0])
javaList.add("Java")
println(kotlinList.size)

medium

A. Kotlin
0

B. Kotlin
1

C. Kotlin
2

D. Compilation error

Solution

1. Step 1: Understand Kotlin wrapping Java list

   The Kotlin List wraps the Java ArrayList directly, so changes to javaList reflect in kotlinList.

2. Step 2: Trace the code output

   First print prints "Kotlin" (element at index 0). Then adding "Java" to javaList increases size to 2, so second print outputs 2.

3. Final Answer:

   Kotlin 2 -> Option C

4. Quick Check:

   Wrapped list reflects changes = A [OK]

Hint: Kotlin List wraps Java list, reflects changes instantly [OK]

Common Mistakes:

• Assuming kotlinList is a copy and size stays 1
• Expecting compilation error due to Java interop
• Confusing index access with size

4. Consider this Kotlin code snippet:

val javaList = java.util.ArrayList<String>()
val kotlinList: MutableList<String> = javaList
kotlinList.add("Hello")
println(javaList.size)

What is the problem with this code?

medium

A. It compiles but javaList.size remains 0.

B. It compiles and javaList.size becomes 1.

C. It causes a runtime ClassCastException.

D. It causes a compilation error due to type mismatch.

Solution

1. Step 1: Analyze Kotlin-Java mutable list assignment

   Assigning a Java ArrayList to a Kotlin MutableList variable works because Kotlin treats Java mutable collections as mutable Kotlin collections.

2. Step 2: Trace mutation effect

   Adding "Hello" to kotlinList modifies the underlying javaList, so javaList.size becomes 1.

3. Final Answer:

   It compiles and javaList.size becomes 1. -> Option B

4. Quick Check:

   Mutable Kotlin list wraps Java list, changes reflect = A [OK]

Hint: Mutable Kotlin list wraps Java list; changes affect both [OK]

Common Mistakes:

• Expecting runtime ClassCastException
• Thinking javaList.size stays 0 after add
• Assuming compilation error on assignment

5. You have a Java HashMap<String, Integer> and want to use it in Kotlin as a mutable map without copying. Which Kotlin code correctly achieves this and allows modifying the map?

hard

A. val javaMap = java.util.HashMap()
val kotlinMap: Map = javaMap.toMap()

B. val javaMap = java.util.HashMap()
val kotlinMap: Map = javaMap as Map

C. val javaMap = java.util.HashMap()
val kotlinMap: MutableMap = javaMap.toMutableMap()

D. val javaMap = java.util.HashMap()
val kotlinMap: MutableMap = javaMap

Solution

1. Step 1: Understand Kotlin-Java map interop

   Kotlin mutable maps can directly wrap Java mutable maps like HashMap without copying.

2. Step 2: Evaluate options for mutability and copying

   The direct assignment val kotlinMap: MutableMap<String, Int> = javaMap wraps the Java HashMap without copying and preserves mutability. In contrast, toMap() and casting to Map provide immutable access, while toMutableMap() creates a new mutable copy.

3. Final Answer:

   val javaMap = java.util.HashMap<String, Int>() val kotlinMap: MutableMap<String, Int> = javaMap -> Option D

4. Quick Check:

   Assign Java HashMap to MutableMap for no copy and mutability = B [OK]

Hint: Assign Java HashMap directly to MutableMap for no copy [OK]

Common Mistakes:

• Using toMap() or toMutableMap() which copies
• Casting to Map loses mutability
• Assuming Kotlin creates a new map automatically