When to use sequences in Kotlin

Introduction

Sequences help process large or complex data step-by-step without using too much memory.

When working with very large lists or collections that don't fit well in memory.

When you want to perform multiple operations on data but avoid creating many temporary lists.

When you want to improve performance by processing items lazily, one at a time.

When you have a chain of operations like filter, map, and take, and want to stop early.

When you want to read data from a source like a file or network and process it as it arrives.

Syntax

Kotlin

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

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

Sequences process elements lazily, meaning they do work only when needed.

Examples

Filter even numbers lazily, then convert back to list.

Kotlin

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

Process a large range lazily and take only first 5 matching items.

Kotlin

val largeList = (1..1_000_000).asSequence()
val firstFive = largeList.filter { it % 3 == 0 }.take(5).toList()

Map words to their lengths using a sequence.

Kotlin

val words = listOf("apple", "banana", "cherry").asSequence()
val lengths = words.map { it.length }.toList()

Sample Program

This program uses a sequence to filter numbers divisible by 1000, doubles them, and prints the list.

Kotlin

fun main() {
    val numbers = (1..10_000).asSequence()
    val result = numbers.filter { it % 1000 == 0 }
                        .map { it * 2 }
                        .toList()
    println(result)
}

Important Notes

Sequences are great for chaining many operations without creating intermediate collections.

Remember to convert back to a list or other collection if you need to use the results multiple times.

Using sequences can improve performance and reduce memory use for big data.

Summary

Sequences process data lazily, saving memory and time.

Use sequences when working with large or complex data chains.

Convert collections to sequences with asSequence() and back with toList().