Kotlin : 100 Interview Questions and Answers PART7

31. Explain withContext() function in Kotlin coroutines

In Kotlin Coroutines, withContext() is a suspending function used to switch the coroutine context (i.e., the thread or dispatcher) in a safe, concise, and structured way.

Syntax

suspend fun <T> withContext(
    context: CoroutineContext,
    block: suspend CoroutineScope.() -> T
): T

Purpose:

• Switch dispatcher (e.g., from IO to Main)
• Do work in a specific thread pool
• Return a result
• Block until completion (without blocking the thread)

Best Practices :

• Use withContext(Dispatchers.IO) for disk or network
• Use withContext(Dispatchers.Default) for CPU-heavy work
• Use Dispatchers.Main for UI updates (on Android)

32. Difference Between launch, async, and withContext

33. Explain flow in Kotlin coroutines .

In Kotlin, Flow is a part of the Kotlin Coroutines library and represents a cold asynchronous data stream that can emit multiple values sequentially.

What is Flow?

• It's similar to RxJava's Observable or Java Streams, but it's designed for use with Kotlin coroutines.
• Flow emits data over time.
• Each emitted value can be collected using a coroutine.

Basic Flow Structure

fun getNumbers(): Flow<Int> = flow {
    for (i in 1..5) {
        delay(1000) // simulate some work
        emit(i)     // emit value
    }
}

Key Flow Operators

Types of Flows

34. Explain hot and cold streams.

In Kotlin's Flow API, the concepts of hot and cold streams describe how data producers behave in relation to their consumers. These concepts are critical for building reactive, efficient, and predictable asynchronous programs.

Cold Streams

💡 Definition:

A cold stream is lazy — it starts emitting data only when there is a collector. Each collector gets its own stream of emissions.

Example:

val coldFlow = flow {
    println("Flow started")
    emit("Hello")
    emit("World")
}

runBlocking {
    coldFlow.collect { println("Collector 1: $it") }
    coldFlow.collect { println("Collector 2: $it") }
}

Flow started
Collector 1: Hello
Collector 1: World
Flow started
Collector 2: Hello
Collector 2: World

Use Case:

• API calls
• File reads
• Any data that should be re-fetched on every collection

Hot Streams

💡 Definition:

A hot stream emits values regardless of collectors. Collectors may miss data if they subscribe late.

 Example using MutableSharedFlow (a hot stream):

val hotFlow = MutableSharedFlow<String>()

// Emitting in a coroutine
GlobalScope.launch {
    hotFlow.emit("🔥 Event 1")
    delay(100)
    hotFlow.emit("🔥 Event 2")
}

// Collecting later
runBlocking {
    delay(200)
    hotFlow.collect {
        println("Collector received: $it")
    }
}

Output:

May be nothing or only Event 2, depending on timing.

Use Case:

• Live data updates
• UI events (clicks, navigation)
• WebSocket or push notifications

Cold vs Hot Flow in Kotlin

35. What is StateFlow in Kotlin?

StateFlow is a state-holder observable flow introduced in Kotlin Coroutines. It is a part of the kotlinx.coroutines.flow library and is a cold flow that always holds the latest emitted value, just like LiveData in Android, but more powerful and flexible.

Key Concepts of StateFlow

Basic Declaration

private val _counter = MutableStateFlow(0)  // Mutable (for internal updates)
val counter: StateFlow<Int> = _counter      // Read-only exposed to external use

When to Use StateFlow:

• 1. In ViewModel to hold and observe UI state
• 2. For Jetpack Compose state management
• 3. To replace LiveData in modern Kotlin-based apps
• 4. When you need a current state + flow updates
•  

36. StateFlow vs LiveData