Flow operators (map, filter, transform) in Kotlin - Step-by-Step Execution

Concept Flow - Flow operators (map, filter, transform)

Start Flow

↓

Apply filter

↓

Apply map

↓

Apply transform

↓

Collect/Output

↓

End

The flow starts by emitting values, then filters them, maps each value, transforms with custom logic, and finally collects the results.

Execution Sample

Kotlin

flowOf(1, 2, 3, 4)
  .filter { it % 2 == 0 }
  .map { it * 10 }
  .transform { emit(it + 1) }
  .collect { println(it) }

This code creates a flow of numbers, filters even numbers, multiplies them by 10, adds 1 to each, and prints the results.

Execution Table

Step	Input Value	Filter Condition (even?)	After Filter	Map Operation (*10)	Transform Operation (+1)	Output (emit)
1	1	1 % 2 == 0 ? False	Filtered out	-	-	-
2	2	2 % 2 == 0 ? True	2	2 * 10 = 20	20 + 1 = 21	21
3	3	3 % 2 == 0 ? False	Filtered out	-	-	-
4	4	4 % 2 == 0 ? True	4	4 * 10 = 40	40 + 1 = 41	41
-	-	-	-	-	-	Flow ends, no more values

💡 All input values processed; flow completes after last value.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
inputValue	N/A	1	2	3	4
filteredValue	N/A	null	2	null	4
mappedValue	N/A	N/A	20	N/A	40
transformedValue	N/A	N/A	21	N/A	41

Key Moments - 3 Insights

Why does the value 1 not appear in the output?

Because in the execution_table row 1, the filter condition is false for 1, so it is filtered out and does not proceed to map or transform.

What does the transform operator do differently than map?

Transform allows emitting zero, one, or multiple values per input and can contain custom logic, while map strictly transforms one input to one output. See execution_table rows 2 and 4 for transform emitting values.

Why is there a '-' in map and transform columns for filtered out values?

Because those values never reach map or transform operators after being filtered out, so no operations are performed on them.

Visual Quiz - 3 Questions

Look at the execution_table at step 2. What is the output emitted after transform?

A 21

B 20

C 2

D 41

💡 Hint

Check the 'Transform Operation (+1)' and 'Output (emit)' columns in row 2 of execution_table.

At which step does the filter condition become false for the first time?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Filter Condition (even?)' column in execution_table rows 1 and 3.

If the filter condition was changed to allow all numbers, what would be the output at step 1?

A 1

B 11

C 10

D 21

💡 Hint

Consider that map multiplies by 10 and transform adds 1, so for input 1: (1*10)+1=11.

Concept Snapshot

Flow operators in Kotlin:
- filter: keeps values matching condition
- map: transforms each value
- transform: custom emit logic, can emit multiple values
Use chaining: flow.filter{}.map{}.transform{}.collect{}

Full Transcript

This example shows a Kotlin flow starting with values 1 to 4. The filter operator removes odd numbers (1 and 3). The map operator multiplies remaining numbers by 10. The transform operator adds 1 and emits the result. Finally, collect prints emitted values. Step-by-step, values 2 and 4 pass filter, become 20 and 40 after map, then 21 and 41 after transform, and are printed. Values 1 and 3 are filtered out early and do not appear in output.

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