Lazy property delegation in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code using lazy delegation?

Consider the following Kotlin code snippet. What will be printed when the program runs?

Kotlin

class Example {
    val lazyValue: String by lazy {
        println("Computed!")
        "Hello"
    }
}

fun main() {
    val example = Example()
    println("Before accessing lazyValue")
    println(example.lazyValue)
    println(example.lazyValue)
}

A

Before accessing lazyValue
Computed!
Hello
Hello

B

Computed!
Before accessing lazyValue
Hello
Hello

C

Before accessing lazyValue
Hello
Computed!
Hello

D

Before accessing lazyValue
Hello
Hello
Computed!

💡 Hint

Remember that the lazy block runs only once, when the property is accessed the first time.

The lazy block prints "Computed!" only once when lazyValue is accessed the first time. The first println prints the message before accessing lazyValue. Then accessing lazyValue triggers the lazy block, printing "Computed!" and returning "Hello". The second access just returns "Hello" without recomputing.

🧠 Conceptual

intermediate

What happens if you access a lazy property from multiple threads without synchronization?

In Kotlin, if a lazy property is declared with the default lazy() delegate and accessed from multiple threads simultaneously, what is the expected behavior?

A The lazy block is executed exactly once in a thread-safe manner.

B The lazy block may be executed multiple times concurrently, causing race conditions.

C The program will throw a runtime exception due to concurrent access.

D The lazy property will always return null if accessed from multiple threads.

💡 Hint

Check the default thread safety mode of Kotlin's lazy delegate.

By default, Kotlin's lazy delegate uses SYNCHRONIZED mode, which ensures the lazy block is executed only once safely even with multiple threads.

❓ Predict Output

advanced

What is the output of this Kotlin code with custom lazy mode?

Analyze the following Kotlin code. What will be printed when main() runs?

Kotlin

class Test {
    val lazyValue: String by lazy(LazyThreadSafetyMode.NONE) {
        println("Calculating...")
        "Done"
    }
}

fun main() {
    val test = Test()
    println(test.lazyValue)
    println(test.lazyValue)
}

A

Done
Done
Done

B

Done
Calculating...
Done

C

Calculating...
Calculating...
Done
Done

D

Calculating...
Done
Done

💡 Hint

LazyThreadSafetyMode.NONE disables synchronization but does not change the single execution behavior in single-threaded code.

With LazyThreadSafetyMode.NONE, the lazy block runs once when first accessed. It prints "Calculating..." once and returns "Done" twice.

🔧 Debug

advanced

Why does this Kotlin lazy property cause a NullPointerException?

Examine the code below. Why does accessing lazyValue cause a NullPointerException?

Kotlin

class Demo {
    val lazyValue: String by lazy {
        null!!.toString()
    }
}

fun main() {
    val demo = Demo()
    println(demo.lazyValue)
}

A The NullPointerException occurs because lazyValue is accessed before the Demo object is fully constructed.

B The lazy property is not initialized properly because lazy requires a non-null initializer.

C The lazy block throws a NullPointerException because null!! forces a null dereference.

D The code compiles but prints "null" without exception.

💡 Hint

Look at the expression inside the lazy block carefully.

The expression null!! throws a NullPointerException immediately when the lazy block runs. This causes the exception on first access.

🚀 Application

expert

How many times is the initializer called in this Kotlin lazy property example with multiple accesses?

Given the code below, how many times will the initializer block inside lazy be executed?

Kotlin

class Counter {
    var count = 0
    val lazyValue: String by lazy {
        count++
        "Counted"
    }
}

fun main() {
    val c = Counter()
    println(c.lazyValue)
    println(c.lazyValue)
    println(c.lazyValue)
    println(c.count)
}

A 0

B 1

C 3

D 4

💡 Hint

The lazy initializer runs only once regardless of how many times the property is accessed.

The lazy block runs once on the first access, incrementing count once. Subsequent accesses do not run the block again.