Android Interview Series 2024 — Part 6 (Kotlin Flows)

5. What are Terminal operators in Flow?

Terminal operators are operators that collect the values emitted by a flow and perform a final action on them. Terminal operators are responsible for starting the flow’s collection process, meaning that until a terminal operator is invoked, the flow remains cold and does not produce any values. Different types of terminal operators:

• collect: is used to receive each emitted value from the flow and perform a specified action on it.

flowOf(1, 2, 3).collect { value ->
println("Received: $value")
}

• toList collects all emitted values and stores them in a List, returning the list when the flow completes. Useful when you want to gather all items from a flow into a list.

val resultList = flowOf(1, 2, 3).toList()
println(resultList) // Output: [1, 2, 3]

• toSet collects all emitted values into a Set, eliminating duplicates, and returns the set when the flow completes.

val resultSet = flowOf(1, 2, 2, 3).toSet()
println(resultSet) // Output: [1, 2, 3]

• first returns the first value emitted by the flow and then immediately cancels further collection. firstOrNull is similar but returns null if the flow is empty.

val firstValue = flowOf(1, 2, 3).first()
println(firstValue) // Output: 1

• last collects all values and returns the last emitted value. If the flow is empty, it throws an exception. lastOrNull returns the last emitted value or null if the flow is empty.

val lastValue = flowOf(1, 2, 3).last()
println(lastValue) // Output: 3

• single expects the flow to emit exactly one value. If the flow emits more than one value, it throws an exception. singleOrNull returns null if the flow is empty, and if there’s only one item, it returns that item. It throws an exception if the flow emits more than one item.

val singleValue = flowOf(42).single()
println(singleValue) // Output: 42

• reduce performs a reduction operation, accumulating values as they are emitted by the flow. This operator applies an accumulator function to combine values and returns the final accumulated result. It’s similar to fold, but reduce doesn’t take an initial value and starts with the first emitted value as the initial accumulator.

val sum = flowOf(1, 2, 3, 4).reduce { accumulator, value ->
accumulator + value
}
println(sum) // Output: 10

• fold is similar to reduce, but it allows you to specify an initial value for the accumulation. This is useful if you want to start the accumulation with a specific value (e.g., an initial count or sum).

val sumWithInitial = flowOf(1, 2, 3, 4).fold(10) { accumulator, value ->
accumulator + value
}
println(sumWithInitial) // Output: 20

• count counts the number of items emitted by the flow that satisfy a given predicate and returns the count. If no predicate is provided, it counts all items emitted.

val count = flowOf(1, 2, 3, 4).count { it % 2 == 0 }
println(count) // Output: 2 (counts 2 and 4)

6. What does the launchIn keyword do?

launchIn collects the flow within a specific coroutine scope without blocking the calling coroutine. It is often used when working with hot flows and when you want to start collecting in a different coroutine scope. Unlike other terminal operators, launchIn doesn’t wait for the flow to complete but runs it in a separate coroutine.

val scope = CoroutineScope(Dispatchers.Default)
flowOf(1, 2, 3)
.onEach { println("Received: $it") }
.launchIn(scope)

7. What is the difference between StateIn and ShareIn?

stateIn and shareIn are operators used to convert a Flow into a hot flow that can be shared among multiple collectors. Both are commonly used for transforming cold flows into hot flows that keep data in memory and emit it to multiple subscribers.

The stateIn operator converts a cold Flow into a StateFlow, which is a hot flow that retains the latest emitted value and always has a single current state.

• When a new collector starts collecting, it immediately receives the latest value held in StateFlow, even if it started after that value was emitted.
• Since StateFlow must always have a value, stateIn requires an initial value that will be emitted until the flow starts producing data.
• StateFlow always retains the latest emitted value, making it ideal for state management where you need to hold a “single source of truth” that represents the current state.
• New collectors receive the latest value immediately upon subscription, even if they subscribe after the value was emitted.