Map-backed delegated properties in Kotlin - Time & Space Complexity

Time Complexity: Map-backed delegated properties

O(1)

Understanding Time Complexity

We want to understand how fast or slow accessing properties through a map-backed delegate is.

Specifically, how does the time to get or set a property change as the map size grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int     by map
}

fun main() {
    val userData = mapOf("name" to "Alice", "age" to 30)
    val user = User(userData)
    println(user.name)
    println(user.age)
}
    

This code uses a map to store property values and accesses them via delegated properties.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Accessing a value in the map by key.
• How many times: Once per property access.

How Execution Grows With Input

Each property access looks up a key in the map. The time depends on the map's lookup speed.

Input Size (n)	Approx. Operations
10	About 1 lookup per property access
100	Still about 1 lookup per property access
1000	Still about 1 lookup per property access

Pattern observation: The time to access a property stays roughly the same no matter how big the map is.

Final Time Complexity

Time Complexity: O(1)

This means each property access takes about the same time regardless of how many entries are in the map.

Common Mistake

[X] Wrong: "Accessing a property through a map delegate gets slower as the map grows because it has to search more entries."

[OK] Correct: Kotlin uses a hash map for storage, so key lookups are very fast and do not slow down noticeably as the map grows.

Interview Connect

Understanding how map-backed delegates work helps you reason about property access speed in Kotlin, a useful skill for writing efficient and clean code.

Self-Check

"What if the map was replaced with a list of pairs instead? How would the time complexity of property access change?"