Lazy property delegation in Kotlin

Introduction

Lazy property delegation helps you create a value only when you need it, saving time and resources.

When a property value is expensive to create and you want to delay its creation until it's actually needed.

When you want to avoid unnecessary calculations or loading data until the property is accessed.

When you want to improve app startup time by delaying some work.

When you want to cache a value after the first calculation so it doesn't run again.

When you want simple, clean code to handle delayed initialization.

Syntax

Kotlin

val propertyName: Type by lazy {
    // code to create the value
}

The lazy block runs only once, the first time you access the property.

After that, the same value is returned every time without running the block again.

Examples

This example prints a message only once when greeting is first accessed, then returns the string.

Kotlin

val greeting: String by lazy {
    println("Computing greeting...")
    "Hello, Kotlin!"
}

A simple lazy property that returns 42 when accessed for the first time.

Kotlin

val number: Int by lazy { 42 }

Sample Program

This program shows that the lazy block runs only once, even if the property is accessed multiple times.

Kotlin

fun main() {
    val lazyValue: String by lazy {
        println("Calculating lazyValue...")
        "I am lazy"
    }

    println("Before accessing lazyValue")
    println(lazyValue)
    println(lazyValue)
}

Important Notes

Lazy properties are thread-safe by default, so they work well in multi-threaded apps.

If you want a different thread-safety mode, you can pass a parameter to lazy().

Summary

Lazy property delegation delays creating a value until it is needed.

The value is created once and reused on later accesses.

This helps save resources and keeps code clean.

Practice

1. What does lazy property delegation in Kotlin do?

easy

A. Deletes the property value after each use

B. Delays the creation of a property value until it is first accessed

C. Creates the property value immediately when the object is created

D. Allows multiple values to be stored in the same property

Solution

1. Step 1: Understand lazy delegation concept

   Lazy delegation means the property value is not created when the object is made, but only when the property is accessed for the first time.

2. Step 2: Compare options with this concept

   Delays the creation of a property value until it is first accessed matches this behavior exactly. Options A, B, and D describe different behaviors not related to lazy delegation.

3. Final Answer:

   Delays the creation of a property value until it is first accessed -> Option B

4. Quick Check:

   Lazy property = delayed creation [OK]

Hint: Lazy means create value only when first needed [OK]

Common Mistakes:

• Thinking lazy creates value immediately
• Confusing lazy with caching multiple values
• Assuming lazy deletes values after use

2. Which of the following is the correct syntax to declare a lazy property in Kotlin?

easy

A. val name = lazy("John")

B. val name = lazy { "John" }

C. val name by lazy { "John" }

D. lazy val name = "John"

Solution

1. Step 1: Recall Kotlin lazy syntax

   In Kotlin, lazy properties use the syntax: val propertyName by lazy { initializer }.

2. Step 2: Match options with correct syntax

   val name by lazy { "John" } matches this exactly. val name = lazy { "John" } assigns lazy delegate but does not use 'by'. lazy val name = "John" uses invalid order. val name = lazy("John") uses wrong function call syntax.

3. Final Answer:

   val name by lazy { "John" } -> Option C

4. Quick Check:

   Use 'by lazy { }' for lazy property [OK]

Hint: Remember: val x by lazy { ... } [OK]

Common Mistakes:

• Omitting 'by' keyword
• Using lazy() as a function call incorrectly
• Placing 'lazy' before 'val'

3. What will be the output of this Kotlin code?

val lazyValue by lazy {
    println("Computing...")
    10
}

fun main() {
    println(lazyValue)
    println(lazyValue)
}

medium

A. Computing...\n10\n10

B. 10\n10

C. Computing...\n10\nComputing...\n10

D. Computing...\nComputing...\n10\n10

Solution

1. Step 1: Understand lazy initialization behavior

   The lambda inside lazy runs only once, when the property is first accessed. It prints "Computing..." and returns 10.

2. Step 2: Trace the program output

   First println(lazyValue) triggers lazy initialization, printing "Computing..." then 10. Second println(lazyValue) uses cached value, printing only 10.

3. Final Answer:

   Computing...\n10\n10 -> Option A

4. Quick Check:

   Lazy runs once, then caches value [OK]

Hint: Lazy block runs once, then cached value used [OK]

Common Mistakes:

• Assuming lazy block runs every access
• Missing that println inside lazy prints once
• Confusing output order

4. Identify the error in this Kotlin code using lazy delegation:

class Example {
    val number = lazy { 5 }
}

fun main() {
    val e = Example()
    println(e.number)
}

medium

A. The lazy block must return a String, not Int

B. The println statement is missing parentheses

C. The lazy delegate cannot be used inside a class

D. The property 'number' should be declared with 'by lazy', not assigned directly

Solution

1. Step 1: Check lazy property declaration

   The property 'number' is assigned lazy { 5 } directly, but lazy delegation requires 'by lazy' syntax.

2. Step 2: Identify correct syntax

   Correct declaration is 'val number by lazy { 5 }'. Without 'by', 'number' is a Lazy<Int> object, not the Int value.

3. Final Answer:

   The property 'number' should be declared with 'by lazy', not assigned directly -> Option D

4. Quick Check:

   Use 'by lazy' keyword for lazy properties [OK]

Hint: Lazy needs 'by lazy', not just assignment [OK]

Common Mistakes:

• Omitting 'by' keyword
• Confusing lazy delegate type with property type
• Thinking lazy only works outside classes

5. You want to create a Kotlin class where a heavy computation is done only once and reused, but the computation depends on a constructor parameter. How should you use lazy delegation to achieve this?

class Calculator(val input: Int) {
    val result by lazy { /* ??? */ }
}

Which is the correct way to implement the lazy block?

hard

A. val result by lazy { compute() } // where compute() is a member function

B. val result by lazy { Calculator(input).compute() }

C. val result by lazy { input }

D. val result by lazy { input * 2 }

Solution

1. Step 1: Understand lazy with constructor parameter

   The lazy block can access constructor parameters and member functions. Using a member function keeps code clean and reusable.

2. Step 2: Evaluate options

   val result by lazy { input * 2 } uses input directly, which works but may duplicate logic. val result by lazy { Calculator(input).compute() } creates a new Calculator inside lazy, causing recursion. val result by lazy { input } just returns input, no computation. val result by lazy { compute() } // where compute() is a member function calls a member function compute(), which can use input and perform heavy work once.

3. Final Answer:

   val result by lazy { compute() } // where compute() is a member function -> Option A

4. Quick Check:

   Use member function inside lazy for complex computation [OK]

Hint: Call member function inside lazy for complex work [OK]

Common Mistakes:

• Creating new instance inside lazy causing recursion
• Using constructor parameter directly without logic
• Returning parameter without computation