Why object declarations create singletons in Kotlin - Performance Analysis

Time Complexity: Why object declarations create singletons

O(n)

Understanding Time Complexity

Let's explore how Kotlin's object declarations behave when creating singletons.

We want to understand how the cost of creating and accessing these objects changes as the program runs.

Scenario Under Consideration

Analyze the time complexity of this Kotlin object declaration and its usage.

object Logger {
    fun log(message: String) {
        println(message)
    }
}

fun main() {
    Logger.log("Start")
    Logger.log("End")
}
    

This code defines a singleton Logger object and calls its log function twice.

Identify Repeating Operations

Look for repeated actions or object creations.

• Primary operation: Calling Logger.log() twice.
• How many times: Twice in this example, but could be many times in a real program.
• Object creation: Happens only once when Logger is first accessed.

How Execution Grows With Input

Each call to Logger.log() runs a simple print operation.

Input Size (number of calls)	Approx. Operations
10	10 print calls, 1 object creation
100	100 print calls, 1 object creation
1000	1000 print calls, 1 object creation

Notice the object is created only once, no matter how many times we call log().

Final Time Complexity

Time Complexity: O(n)

This means the total time grows linearly with the number of log calls, but the object creation cost stays constant.

Common Mistake

[X] Wrong: "The Logger object is created every time we call log()."

[OK] Correct: Kotlin creates the object only once when first used, so repeated calls reuse the same instance.

Interview Connect

Understanding how Kotlin manages object declarations helps you explain efficient resource use and singleton patterns clearly.

Self-Check

What if we replaced the object declaration with a class and created a new instance each time? How would the time complexity change?