StateFlow for observable state in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this StateFlow example?

Consider this Kotlin code using StateFlow. What will be printed?

Kotlin

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

fun main() = runBlocking {
    val stateFlow = MutableStateFlow(0)

    launch {
        stateFlow.collect { value ->
            println("Collected: $value")
        }
    }

    delay(100)
    stateFlow.value = 1
    delay(100)
    stateFlow.value = 2
    delay(100)
    cancel()
}

A

Collected: 0
Collected: 1
Collected: 2

B

Collected: 0
Collected: 1
Collected: 1
Collected: 2

C

Collected: 0
Collected: 0
Collected: 1
Collected: 2

D

Collected: 1
Collected: 2

💡 Hint

Remember that StateFlow always emits the current value immediately to new collectors.

The MutableStateFlow starts with 0. When collect starts, it immediately emits 0. Then, when the value changes to 1 and 2, those values are emitted as well.

🧠 Conceptual

intermediate

What happens when multiple collectors subscribe to the same StateFlow?

Given a StateFlow instance, what is true about multiple collectors?

A Each collector receives the current value immediately and all future updates independently.

B Only the first collector receives updates; others get no values.

C Collectors share a single emission, so only one collector gets each update.

D Collectors receive values only if they subscribe before the first emission.

💡 Hint

Think about how StateFlow behaves like a hot stream that always holds the latest value.

StateFlow is a hot stream that holds the latest value. Every collector immediately receives the current value and then all future updates independently.

🔧 Debug

advanced

Why does this StateFlow collector never print updates?

Look at this Kotlin code snippet. Why does the collector never print any updates?

Kotlin

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

fun main() = runBlocking {
    val stateFlow = MutableStateFlow(0)

    stateFlow.collect { value ->
        println("Value: $value")
    }

    stateFlow.value = 1
    delay(100)
}

A The <code>collect</code> call is missing a coroutine scope, so it never starts.

B The <code>stateFlow.value</code> assignment happens before <code>collect</code>, so no updates are printed.

C The collector blocks the coroutine, so the value update never happens.

D The <code>delay</code> is too short to allow collection to start.

💡 Hint

Consider how collect works in a coroutine and what happens after it.

The collect call is a suspending function that blocks until the flow completes. Since stateFlow never completes, the code after collect (the value assignment) never runs, so no updates happen.

📝 Syntax

advanced

Which option correctly creates a StateFlow with initial value 5 and updates it to 10?

Choose the correct Kotlin code snippet that creates a MutableStateFlow with initial value 5 and then updates it to 10.

A

val stateFlow = StateFlow(5)
stateFlow.value = 10

B

val stateFlow = MutableStateFlow(5)
stateFlow.emit(10)

C

val stateFlow = MutableStateFlow<Int>(5)
stateFlow.value = 10

D

val stateFlow = MutableStateFlow(5)
stateFlow.value = 10

💡 Hint

Remember how to create and update a MutableStateFlow.

MutableStateFlow is created with an initial value. You update its value by assigning to value. The emit function is not available on MutableStateFlow. Also, StateFlow is an interface and cannot be instantiated directly.

🚀 Application

expert

How to combine two StateFlows to produce a new StateFlow with their sum?

You have two StateFlow<Int> instances: flowA and flowB. Which code snippet correctly creates a new StateFlow<Int> that always holds the sum of the latest values from flowA and flowB?

A val sumFlow = MutableStateFlow(flowA.value + flowB.value)

B val sumFlow = flowA.combine(flowB) { a, b -> a + b }.stateIn(scope, SharingStarted.Eagerly, 0)

C val sumFlow = flowA.map { a -> a + flowB.value } as StateFlow<Int>

D val sumFlow = flowA.zip(flowB) { a, b -> a + b }.stateIn(scope, SharingStarted.Lazily, 0)

💡 Hint

Think about how to combine two flows reactively and keep a StateFlow result.

The combine operator merges two flows and emits a new value whenever either changes. Using stateIn converts the combined flow into a StateFlow that holds the latest sum. zip waits for paired emissions and map with direct access to flowB.value is not reactive to changes in flowB. Creating a new MutableStateFlow with initial sum won't update automatically.