Platform types from Java interop in Kotlin - Time & Space Complexity

Time Complexity: Platform types from Java interop

O(n)

Understanding Time Complexity

When Kotlin code uses Java code, some types come without clear nullability. This affects how Kotlin handles them.

We want to understand how this uncertainty impacts the time it takes to run Kotlin programs using Java types.

Scenario Under Consideration

Analyze the time complexity of the following Kotlin code calling Java methods with platform types.

fun processJavaList(javaList: List) {
    for (item in javaList) {
        if (item != null) {
            println(item.length)
        }
    }
}
    

This code loops over a Java list that may contain nulls, checking each item before using it.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each element of the list.
• How many times: Once for every item in the list (n times).

How Execution Grows With Input

As the list grows, the number of checks and prints grows directly with the number of items.

Input Size (n)	Approx. Operations
10	About 10 checks and prints
100	About 100 checks and prints
1000	About 1000 checks and prints

Pattern observation: The work grows evenly as the list size grows.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the number of items in the list.

Common Mistake

[X] Wrong: "Because platform types can be null, the loop might do extra hidden work that slows it down a lot."

[OK] Correct: The null checks are simple and happen once per item, so they only add a small, predictable cost that grows linearly.

Interview Connect

Understanding how Kotlin handles Java platform types helps you reason about performance when mixing languages, a useful skill in many projects.

Self-Check

"What if the Java list was replaced with a Kotlin list that guarantees no nulls? How would the time complexity change?"