FlowOn for changing dispatcher in Kotlin - Time & Space Complexity

Time Complexity: FlowOn for changing dispatcher

O(n)

Understanding Time Complexity

When using flowOn in Kotlin flows, we want to understand how switching the dispatcher affects the time it takes to run the flow operations.

We ask: How does changing the dispatcher with flowOn impact the number of steps the program takes?

Scenario Under Consideration

Analyze the time complexity of this Kotlin flow snippet using flowOn.

val flow = flow {
    for (i in 1..n) {
        emit(i)
    }
}.flowOn(Dispatchers.IO)

flow.collect { value ->
    println(value)
}
    

This code emits numbers from 1 to n on the IO dispatcher, then collects and prints them on the main thread.

Identify Repeating Operations

Look at the repeating parts of the code.

• Primary operation: The for loop emits n values.
• How many times: Exactly n times, once per number.

How Execution Grows With Input

As n grows, the number of emitted values grows linearly.

Input Size (n)	Approx. Operations
10	About 10 emits and prints
100	About 100 emits and prints
1000	About 1000 emits and prints

Pattern observation: The work grows directly with n, doubling n doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the flow grows in a straight line with the number of items emitted.

Common Mistake

[X] Wrong: "Using flowOn makes the flow run faster and changes the time complexity."

[OK] Correct: flowOn only changes where the work happens (which thread), not how many steps the program takes. The number of operations stays the same.

Interview Connect

Understanding how flowOn affects execution helps you explain concurrency and performance clearly, a useful skill in many programming tasks.

Self-Check

What if we added another flowOn with a different dispatcher after the first one? How would that affect the time complexity?