FlatMap for nested collections in Kotlin - Step-by-Step Execution

Concept Flow - FlatMap for nested collections

Start with nested list

↓

Apply flatMap

↓

For each inner list: extract elements

↓

Combine all elements into one list

↓

Return flattened list

↓

End

FlatMap takes each inner collection, extracts its elements, and combines them into one flat list.

Execution Sample

Kotlin

val nested = listOf(listOf(1, 2), listOf(3, 4))
val flat = nested.flatMap { it }
println(flat)

This code flattens a list of lists into a single list of elements.

Execution Table

Step	Action	Input	Output	Notes
1	Start with nested list	listOf(listOf(1, 2), listOf(3, 4))	Same nested list	Initial nested list with two inner lists
2	Apply flatMap	nested list	Process each inner list	flatMap starts processing each inner list
3	Extract elements from first inner list	listOf(1, 2)	1, 2	First inner list elements extracted
4	Extract elements from second inner list	listOf(3, 4)	3, 4	Second inner list elements extracted
5	Combine all elements	1, 2, 3, 4	listOf(1, 2, 3, 4)	All elements combined into one list
6	Print result	listOf(1, 2, 3, 4)	[1, 2, 3, 4]	Final flattened list output

💡 All inner lists processed and combined into one flat list

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
nested	listOf(listOf(1, 2), listOf(3, 4))	Same	Same	Same
flat	undefined	listOf(1, 2)	listOf(1, 2, 3, 4)	listOf(1, 2, 3, 4)

Key Moments - 2 Insights

Why does flatMap return a single list instead of a list of lists?

Because flatMap extracts elements from each inner list and combines them into one list, as shown in steps 3, 4, and 5 of the execution_table.

What is the difference between map and flatMap here?

map would keep the inner lists nested (list of lists), but flatMap flattens them into a single list by combining all elements, as seen in the output of step 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after extracting elements from the first inner list (Step 3)?

A listOf(1, 2)

B listOf(3, 4)

C [1, 2, 3, 4]

D listOf(listOf(1, 2), listOf(3, 4))

💡 Hint

Check the Output column in Step 3 of the execution_table.

At which step does the combined flat list get created?

A Step 4

B Step 5

C Step 2

D Step 6

💡 Hint

Look for the step where all elements are combined into one list in the execution_table.

If we replaced flatMap with map, what would the output look like?

A A single flat list of all elements

B An empty list

C A list of lists, same as the original nested list

D A list with duplicated elements

💡 Hint

Recall the difference between map and flatMap explained in key_moments.

Concept Snapshot

flatMap takes a nested collection and flattens it into a single list.
Syntax: collection.flatMap { innerList -> innerList }
It extracts elements from each inner collection and combines them.
Use flatMap to avoid nested lists when you want a single list of all elements.
map keeps the nested structure; flatMap flattens it.

Full Transcript

This visual trace shows how Kotlin's flatMap works on nested collections. We start with a list of lists: [[1, 2], [3, 4]]. FlatMap processes each inner list, extracting elements one by one. First, it extracts 1 and 2 from the first inner list, then 3 and 4 from the second. It then combines all these elements into a single flat list: [1, 2, 3, 4]. The variable 'flat' holds this combined list. The key difference from map is that flatMap flattens the nested structure into one list, while map would keep the nested lists intact. This step-by-step execution helps beginners see how flatMap transforms nested collections into flat ones.