Lazy evaluation vs eager evaluation in Kotlin

Introduction

Lazy evaluation means waiting to do work until it's really needed. Eager evaluation means doing work right away. This helps save time and resources or get results quickly.

When you want to delay heavy calculations until you actually need the result.

When working with large data sets and want to avoid processing everything at once.

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

When you want to get immediate results for simple tasks without delay.

When you want to control when and how your code runs for better performance.

Syntax

Kotlin

val eagerValue = compute()
val lazyValue by lazy { compute() }

eagerValue runs compute() immediately.

lazyValue runs compute() only when first used.

Examples

This converts "Hello" to uppercase immediately and prints it.

Kotlin

val eager = "Hello".uppercase()
println(eager)

This delays the uppercase conversion until lazyValue is used the first time. The message prints only once.

Kotlin

val lazyValue by lazy {
    println("Computing now...")
    "Hello".uppercase()
}
println("Before using lazyValue")
println(lazyValue)
println(lazyValue)

Sample Program

This program shows the difference. The eager value is computed right away. The lazy value waits until it is printed the first time. The compute function prints a message when it runs, so you can see when it happens.

Kotlin

fun compute(): String {
    println("Computing the value...")
    return "Kotlin"
}

fun main() {
    val eagerValue = compute()  // runs immediately
    println("Eager value: $eagerValue")

    val lazyValue by lazy { compute() }  // runs only when used
    println("Before accessing lazyValue")
    println("Lazy value: $lazyValue")
    println("Accessing lazyValue again: $lazyValue")
}

Important Notes

Lazy evaluation runs the code only once, then remembers the result.

Eager evaluation runs the code immediately, even if the result is never used.

Use lazy evaluation to save resources when the result might not be needed.

Summary

Lazy evaluation delays work until needed, eager evaluation does it right away.

Kotlin's by lazy helps create lazy values easily.

Choosing between lazy and eager depends on when you want your code to run.