Flow operators (map, filter, transform) in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the map operator do in a Kotlin Flow?

The map operator transforms each emitted value from the flow by applying a given function, producing a new flow with the transformed values.

beginner

How does the filter operator work in a Kotlin Flow?

The filter operator lets only those values pass through the flow that satisfy a given condition (predicate). Values that don't meet the condition are skipped.

intermediate

Explain the difference between map and transform operators in Kotlin Flow.

map applies a simple one-to-one transformation on each value. transform is more flexible; it can emit zero, one, or many values for each input and can run suspend functions inside.

intermediate

Can transform operator emit multiple values for a single input in Kotlin Flow?

Yes, transform can emit zero, one, or multiple values for each input value, making it very flexible for complex transformations.

advanced

What is the role of suspend functions inside the transform operator?

Inside transform, you can call suspend functions to perform asynchronous or long-running operations before emitting values, which is not possible with map.

Which Flow operator would you use to change each emitted value to its uppercase string?

A map

B filter

C transform

D collect

The map operator transforms each emitted value, such as converting strings to uppercase.

What does the filter operator do in a Kotlin Flow?

A Transforms values

B Emits multiple values per input

C Emits only values that satisfy a condition

D Collects values

filter lets only values that meet a condition pass through.

Which operator allows emitting multiple values for a single input in Kotlin Flow?

A map

B filter

C take

D transform

transform can emit zero, one, or many values per input.

Can you call suspend functions inside the map operator?

A Yes, always

B No, <code>map</code> does not support suspend functions

C Only if wrapped in <code>withContext</code>

D Only for filtering

map does not support suspend functions; use transform for that.

Which operator would you use to skip values that are less than 10 in a Flow?

A filter

B map

C transform

D reduce

filter is used to skip values that don't meet a condition.

Describe how the map, filter, and transform operators work in Kotlin Flow and when you might use each.

Think about simple vs complex transformations and filtering.

Explain why you might choose transform over map in a Kotlin Flow.

Consider asynchronous operations and multiple emissions.

Practice

1. Which Kotlin Flow operator is used to change each item in the flow to a new value?

easy

A. filter

B. map

C. transform

D. collect

Solution

1. Step 1: Understand the purpose of map

   The map operator changes each item in the flow to a new value by applying a function.

2. Step 2: Compare with other operators

   filter keeps items based on a condition, transform can emit multiple items, and collect gathers items but does not change them.

3. Final Answer:

   map -> Option B

4. Quick Check:

   Change each item = map [OK]

Hint: Map means change each item to a new one [OK]

Common Mistakes:

• Confusing map with filter
• Thinking transform only changes one item
• Using collect to change items

2. Which of the following is the correct syntax to filter even numbers from a Kotlin Flow named numbers?

easy

A. numbers.collect { it % 2 == 0 }

B. numbers.map { it % 2 == 0 }

C. numbers.filter { it % 2 == 0 }

D. numbers.transform { emit(it % 2 == 0) }

Solution

1. Step 1: Identify the filter syntax

   The filter operator takes a lambda returning a Boolean to keep items matching the condition.

2. Step 2: Check each option

   numbers.filter { it % 2 == 0 } correctly uses filter { it % 2 == 0 } to keep even numbers. numbers.map { it % 2 == 0 } uses map which changes items to booleans. numbers.transform { emit(it % 2 == 0) } emits booleans instead of filtering. numbers.collect { it % 2 == 0 } misuses collect.

3. Final Answer:

   numbers.filter { it % 2 == 0 } -> Option C

4. Quick Check:

   Filter even numbers = filter { it % 2 == 0 } [OK]

Hint: Filter keeps items; map changes items [OK]

Common Mistakes:

• Using map instead of filter
• Misusing collect as a filter
• Confusing transform syntax

3. What is the output of this Kotlin Flow code?

flowOf(1, 2, 3, 4)
    .filter { it % 2 == 0 }
    .map { it * 10 }
    .toList()

medium

A. [20, 40]

B. [10, 20]

C. [2, 4]

D. [1, 2, 3, 4]

Solution

1. Step 1: Apply filter to keep even numbers

   The flow starts with [1, 2, 3, 4]. After filtering even numbers, we get [2, 4].

2. Step 2: Apply map to multiply each by 10

   Mapping [2, 4] by multiplying each by 10 results in [20, 40].

3. Final Answer:

   [20, 40] -> Option A

4. Quick Check:

   Filter evens then multiply by 10 = [20, 40] [OK]

Hint: Filter first, then map to change values [OK]

Common Mistakes:

• Mapping before filtering
• Confusing output with original list
• Ignoring order of operators

4. Identify the error in this Kotlin Flow code snippet:

flowOf(1, 2, 3)
    .filter { it > 1 }
    .map { it * 2 }
    .transform { emit(it + 1) }

medium

A. Using transform after map is invalid

B. The filter condition syntax is wrong

C. The emit call inside transform is incorrect

D. The code misses a terminal operator like collect

Solution

1. Step 1: Check the flow operators usage

   The operators filter, map, and transform are used correctly in sequence.

2. Step 2: Identify missing terminal operation

   Flows are cold and need a terminal operator like collect or toList to start processing. This code lacks that.

3. Final Answer:

   The code misses a terminal operator like collect -> Option D

4. Quick Check:

   Flows need terminal operator to run [OK]

Hint: Flows need collect or toList to run [OK]

Common Mistakes:

• Forgetting terminal operator
• Thinking transform can't follow map
• Misreading filter condition syntax

5. Given a Flow of integers, how can you use transform to emit both the original number and its square for each item?

hard

A. flow.transform { emit(it); emit(it * it) }

B. flow.map { listOf(it, it * it) }

C. flow.filter { emit(it); emit(it * it) }

D. flow.collect { emit(it); emit(it * it) }

Solution

1. Step 1: Understand transform usage

   transform allows emitting zero or more items per input, so emitting both original and square is possible.

2. Step 2: Check each option's correctness

   flow.transform { emit(it); emit(it * it) } correctly uses transform with two emit calls. flow.map { listOf(it, it * it) } uses map which emits a list, not separate items. flow.filter { emit(it); emit(it * it) } misuses filter. flow.collect { emit(it); emit(it * it) } misuses collect which is terminal and cannot emit.

3. Final Answer:

   flow.transform { emit(it); emit(it * it) } -> Option A

4. Quick Check:

   Emit multiple items per input = transform [OK]

Hint: Use transform to emit multiple items per input [OK]

Common Mistakes:

• Using map to emit multiple items separately
• Misusing filter or collect for emission
• Not calling emit inside transform