Platform types and null safety in Kotlin - Time & Space Complexity

Time Complexity: Platform types and null safety

O(1)

Understanding Time Complexity

We want to see how Kotlin handles operations when dealing with platform types and null safety.

How does the program's work change when checking for nulls from Java code?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fun printLength(str: String?) {
    if (str != null) {
        println(str.length)
    } else {
        println("Null string")
    }
}

fun usePlatformType(str: String) {
    println(str.length)
}

This code checks string length safely and unsafely using platform types from Java.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Accessing the length property of a string.
• How many times: Once per function call, no loops or recursion involved.

How Execution Grows With Input

The time to check null and get length stays the same no matter the string size.

Input Size (n)	Approx. Operations
10	1 check + 1 length access
100	1 check + 1 length access
1000	1 check + 1 length access

Pattern observation: The number of operations does not grow with input size.

Final Time Complexity

Time Complexity: O(1)

This means the time to run these checks and access length stays constant no matter the input size.

Common Mistake

[X] Wrong: "Checking for null or using platform types makes the program slower as input grows."

[OK] Correct: Null checks and property access happen once per call and do not depend on input size, so they do not slow down as input grows.

Interview Connect

Understanding how null safety checks work helps you write safer Kotlin code and explain your reasoning clearly in interviews.

Self-Check

"What if we added a loop that prints the length of each string in a list? How would the time complexity change?"