Why Flow matters for async sequences in Kotlin

Introduction

Flow helps you handle data that comes over time, like messages or updates, in a simple and safe way.

When you want to get updates from a server one by one.

When you need to process user actions that happen at different times.

When you want to handle streams of data like sensor readings.

When you want to avoid blocking your app while waiting for data.

When you want to combine or transform data that arrives slowly.

Syntax

Kotlin

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100) // pretend we are doing something asynchronous
        emit(i) // emit next value
    }
}

flow { ... } creates a Flow that emits values over time.

emit() sends a value to whoever is collecting the Flow.

Examples

This flow emits three numbers one after another.

Kotlin

val numbersFlow = flow {
    emit(1)
    emit(2)
    emit(3)
}

This collects the flow and prints each value as it arrives.

Kotlin

numbersFlow.collect { value ->
    println("Received $value")
}

This flow emits numbers with a delay, simulating asynchronous data.

Kotlin

val delayedFlow = flow {
    for (i in 1..3) {
        delay(100)
        emit(i)
    }
}

Sample Program

This program creates a flow that emits numbers 1 to 3 with a delay. It collects and prints each number as it arrives.

Kotlin

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i)
    }
}

fun main() = runBlocking {
    println("Start collecting flow")
    simpleFlow().collect { value ->
        println("Received $value")
    }
    println("Done collecting flow")
}

Important Notes

Flow is cold, meaning it does not start until you collect it.

Flow helps keep your app responsive by not blocking the main thread.

You can transform and combine flows easily to handle complex data streams.

Summary

Flow lets you work with data that comes over time in a simple way.

It helps keep your app smooth by handling data asynchronously.

Use Flow when you want to process sequences of events or data updates.