Sequence

Learn lazy computation optimization with Sequence.

What is a Sequence?

A Sequence is a lazily evaluated stream in Kotlin. Each step runs only when the result is needed; no intermediate collection is created.

Example: (1..10).asSequence().map { it * 2 }.filter { it > 5 }.toList(). With List every step creates a new list; a Sequence computes in a single pass. This lowers both allocation and time on large data. The seqInfo model in this lesson shows the concept.

Sequence versus List

List creates a new collection at every step (eager). Sequence processes only as many elements as needed in a single pass (lazy).

For example (1..3).asSequence().map { it * 2 }.joinToString() yields "2, 4, 6"; no intermediate list is created. The difference is small on tiny data; on millions of elements Sequence saves both memory and time. A terminal operation (toList, joinToString) is needed to reach the result.

Exercise Write seqInfo

Define fun seqInfo(): String. Its body should return (1..3).asSequence().map { it * 2 }.joinToString(). In main, write println(seqInfo()).

Show example solution

fun seqInfo(): String = (1..3).asSequence().map { it * 2 }.joinToString()
fun main() {
    println(seqInfo())
}

Test yourself

What kind of computation does a Sequence do?
```
A Sequence does deferred computation.
```
- Eager
- Lazy
- Asynchronous
- Parallel
Show answer

Lazy — A Sequence is evaluated lazily.

Complete the asSequence call

val s = (1..10).____()

Show answer

val s = (1..10).asSequence()

Match the Sequence parts

Sequence

Lazy stream
asSequence

Converter
lazy

Deferred
joinToString

Terminal op

Next lesson: Coroutine overhead

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies