Why sequences matter for performance in Kotlin

Introduction

Sequences help your program run faster by doing work step-by-step instead of all at once.

When you have a big list and want to find something quickly without checking everything.

When you want to save memory by not creating many temporary lists.

When you want to chain many operations like filter and map without slowing down.

When you want your program to start giving results before finishing all work.

Syntax

Kotlin

val result = list.asSequence()
    .filter { it > 10 }
    .map { it * 2 }
    .toList()

Use asSequence() to convert a list to a sequence.

Operations like filter and map are lazy with sequences, meaning they run only when needed.

Examples

This filters numbers greater than 10 using a sequence, so filtering happens lazily.

Kotlin

val numbers = listOf(1, 5, 15, 20)
val result = numbers.asSequence()
    .filter { it > 10 }
    .toList()

This doubles each number lazily before collecting results into a list.

Kotlin

val numbers = listOf(1, 2, 3, 4)
val doubled = numbers.asSequence()
    .map { it * 2 }
    .toList()

This finds the first even number efficiently without checking all items.

Kotlin

val numbers = listOf(1, 2, 3, 4, 5)
val firstEven = numbers.asSequence()
    .filter { it % 2 == 0 }
    .first()

Sample Program

This program uses a sequence to process a large list lazily. It filters even numbers, doubles them, takes the first 5, and prints them.

Kotlin

fun main() {
    val numbers = (1..1_000_000).toList()

    // Using sequences
    val seqResult = numbers.asSequence()
        .filter { it % 2 == 0 }
        .map { it * 2 }
        .take(5)
        .toList()

    println(seqResult)
}

Important Notes

Sequences do not create intermediate lists, saving memory.

Operations on sequences run only when you ask for the result, like with toList() or first().

Using sequences can make your program faster when working with big data or many steps.

Summary

Sequences process data step-by-step, not all at once.

This lazy processing saves memory and can speed up your program.

Use sequences when working with big lists or many operations.