Flow exception handling in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin Flow exception handling code?

Consider the following Kotlin code using flow and catch. What will be printed?

Kotlin

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

fun main() = runBlocking {
    flow {
        emit(1)
        emit(2)
        throw RuntimeException("Error in flow")
    }
    .catch { e -> emit(-1) }
    .collect { value -> println(value) }
}

A

1
2

B

1
2
-1

C

1
-1

D

1
2
Exception in thread "main" java.lang.RuntimeException: Error in flow

💡 Hint

The catch operator catches exceptions and can emit fallback values.

The flow emits 1 and 2, then throws an exception. The catch block catches it and emits -1. So the output is 1, 2, -1.

❓ Predict Output

intermediate

What error does this Kotlin Flow code raise?

What error will this Kotlin code produce when run?

Kotlin

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

fun main() = runBlocking {
    flow {
        emit(1)
        throw IllegalStateException("Oops")
    }
    .collect { value ->
        if (value == 1) throw ArithmeticException("Error in collector")
        println(value)
    }
}

A IllegalStateException: Oops

B NullPointerException

C No error, prints 1

D ArithmeticException: Error in collector

💡 Hint

Exceptions thrown inside collect are not caught by catch in the flow.

The flow emits 1, then the collector throws an ArithmeticException when processing 1. This exception is not caught by the flow's catch, so it propagates.

🧠 Conceptual

advanced

Which operator handles exceptions inside the flow builder?

In Kotlin Flow, which operator is designed to catch exceptions thrown inside the flow builder block?

A <code>catch</code>

B <code>onCompletion</code>

C <code>retry</code>

D <code>collect</code>

💡 Hint

Think about which operator intercepts exceptions during emission.

The catch operator intercepts exceptions thrown inside the flow builder and allows handling or emitting fallback values.

❓ Predict Output

advanced

What is the output of this Kotlin Flow with retry?

What will this Kotlin program print?

Kotlin

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

var attempt = 0

fun main() = runBlocking {
    flow {
        attempt++
        if (attempt < 3) throw Exception("Try again")
        emit("Success on attempt $attempt")
    }
    .retry(2)
    .catch { e -> emit("Failed after retries") }
    .collect { println(it) }
}

A Success on attempt 3

B Failed after retries

C Exception in thread "main" java.lang.Exception: Try again

D Success on attempt 1

💡 Hint

The retry operator retries the flow emission on exceptions.

The flow throws exceptions on attempts 1 and 2, then succeeds on attempt 3. The retry(2) allows two retries, so it succeeds and emits "Success on attempt 3".

🔧 Debug

expert

Why does this Kotlin Flow catch block not catch the exception?

Examine this Kotlin code. Why does the catch block not catch the exception?

Kotlin

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

fun main() = runBlocking {
    flow {
        emit(1)
        emit(2)
    }
    .catch { e -> println("Caught: $e") }
    .collect { value ->
        if (value == 2) throw RuntimeException("Error in collector")
        println(value)
    }
}

A Because the flow does not throw any exception

B Because the catch operator must be before collect to catch exceptions

C Because exceptions in the collector are not caught by the flow's catch operator

D Because RuntimeException is not caught by catch

💡 Hint

Consider where exceptions are thrown and where catch applies.

The catch operator only catches exceptions thrown upstream in the flow builder or operators before collect. Exceptions thrown inside collect are outside its scope and propagate normally.