Advanced Collections (groupBy, fold, windowed)

Reviewed & published by Brayan K

Kotlin's standard library offers powerful collection operators — groupBy, fold, windowed and more — that replace hand-written loops with clear, declarative one-liners.

Part of the free Kotlin course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

You'll group and index data, accumulate with fold/reduce, slice with chunked/windowed, and aggregate with sumOf, maxByOrNull, and zip.

What You'll Learn in This Lesson

• Bucketing with groupBy and indexing with associateBy
• Accumulating with fold and reduce
• Splitting with partition
• Slicing with chunked and sliding windowed
• Expanding and flattening with flatMap
• Aggregating with sumOf, maxByOrNull, and zip

1️⃣ Grouping and Indexing

groupBy { key } buckets elements into a Map<K, List<V>> — every member is kept. associateBy { key } builds a Map<K, V> with one value per key, so on a key collision the last element wins.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5)

    // groupBy: bucket items by a key. Keys appear in first-seen order.
    // 1->1, 2->0, 3->1, 4->0, 5->1
    val byParity = nums.groupBy { it % 2 }
    println(byParity)          // -> {1=[1, 3, 5], 0=[2, 4]}

    val words = listOf("apple", "banana", "avocado")

    // associateBy: build a Map keyed by a function.
    // 'a' appears twice; the LAST one (avocado) wins.
    val byFirst = words.associateBy { it.first() }
    println(byFirst)           // -> {a=avocado, b=banana}
}

2️⃣ Accumulating and Splitting

fold(seed) { acc, x -> ... } accumulates from an initial value and can change type; reduce is the seedless version starting from the first element. partition { ... } splits a list into a pair of (matches, non-matches).

fun main() {
    val nums = listOf(1, 2, 3, 4)

    // fold: start from an initial value and accumulate.
    val sum = nums.fold(0) { acc, x -> acc + x }
    println(sum)               // -> 10

    // reduce: like fold but starts from the FIRST element (no seed).
    val product = nums.reduce { acc, x -> acc * x }
    println(product)           // -> 24  (1*2*3*4)

    // partition: split into (matches, non-matches).
    val (big, small) = nums.partition { it > 2 }
    println(big)               // -> [3, 4]
    println(small)             // -> [1, 2]
}

Remember: reduce throws on an empty list (no first element), while fold safely returns the seed.

3️⃣ Slicing, Flattening, Aggregating

chunked(n) makes non-overlapping batches; windowed(n) makes overlapping sliding windows; flatMap expands each element to a list and flattens. Then sumOf, maxByOrNull, and zip aggregate.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5)

    // chunked: break into fixed-size pieces (last may be smaller).
    println(nums.chunked(2))     // -> [[1, 2], [3, 4], [5]]

    // windowed: sliding windows of a given size.
    println(nums.windowed(2))    // -> [[1, 2], [2, 3], [3, 4], [4, 5]]

    // flatMap: map each item to a list, then flatten one level.
    val pairs = listOf(1, 2).flatMap { listOf(it, it * 10) }
    println(pairs)               // -> [1, 10, 2, 20]
}

fun main() {
    val words = listOf("ab", "cde", "f")

    // sumOf: sum a number derived from each item.
    println(words.sumOf { it.length })       // -> 6  (2+3+1)

    // maxByOrNull: the item with the largest derived value.
    println(words.maxByOrNull { it.length }) // -> cde

    // zip: pair up two lists element by element (stops at shorter).
    val letters = listOf("a", "b", "c")
    val ranks = listOf(1, 2, 3)
    println(letters.zip(ranks))              // -> [(a, 1), (b, 2), (c, 3)]
}

Your turn. Fill in the ___ blanks, then run and compare.

// 🎯 YOUR TURN — replace each ___ then run main()
fun main() {
    val nums = listOf(2, 4, 6, 8)

    // 1) Sum them starting from 0 using fold
    val total = nums.___(0) { acc, x -> acc + x }   // 👉 put: fold

    // 2) Split into >5 and the rest using partition
    val (big, small) = nums.___ { it > 5 }          // 👉 put: partition

    println("$total $big $small")

    // ✅ Expected output:
    // 20 [6, 8] [2, 4]
}

Mini-Challenge: A Word Report

Group words by length and total their letters with groupBy and sumOf.

// 🎯 MINI-CHALLENGE: a small word report.
// Save as WordReport.kt and run main().
//
// 1. Group the words by their length.
// 2. Print the groups map.
// 3. Print the total number of letters using sumOf { it.length }.
//
// ✅ Expected output:
//    {3=[cat, dog], 4=[bird]}
//    10

fun main() {
    val words = listOf("cat", "dog", "bird")
    // 1) val byLength = ...
    // 2) println(byLength)
    // 3) println(total letters)
}

Common Errors (and the fix)

• ❌ "UnsupportedOperationException: Empty collection can't be reduced" — you called reduce on an empty list. ✅ Use fold(seed).
• ❌ Losing data with associateBy — duplicate keys overwrite. ✅ Use groupBy when you need every element.
• ❌ Expecting maxByOrNull to return the value — it returns the element. ✅ Use maxOf for the largest derived value.
• ❌ Using map when you meant flatMap — you get a list of lists. ✅ Use flatMap to flatten one level.

Pro Tips

• 💡 Chain them: real pipelines read like items.filter { }.groupBy { }.mapValues { }.
• 💡 windowed has a step: windowed(3, step = 3) behaves like chunked(3) of full windows.
• 💡 Big data? Add asSequence(): for long chains, a sequence avoids building intermediate lists.

📋 Quick Reference — Operators

🎉 Lesson Complete!

• ✅ groupBy keeps every member; associateBy keeps the last
• ✅ fold takes a seed and is empty-safe; reduce is not
• ✅ chunked batches, windowed slides
• ✅ flatMap expands and flattens one level
• ✅ sumOf, maxByOrNull, and zip aggregate cleanly

Practice quiz

Continue this course

• Previous: Result & runCatching
• Next: Testing in Kotlin (JUnit & kotlin.test) — Write tests with assertEquals, assertFailsWith, and backtick names
• Quick reference: Kotlin cheat sheet

Frequently asked questions

What is the difference between groupBy and associateBy?

Both build a Map from a key function, but they handle collisions differently. groupBy { keyFn } produces a Map<K, List<V>> where every element that shares a key is collected into a list — nothing is lost. associateBy { keyFn } produces a Map<K, V> with a single value per key, so when two elements map to the same key the LAST one wins and earlier ones are overwritten. Use groupBy when you want all members of each bucket; use associateBy when each key should identify exactly one element, like indexing users by id.

When should I use fold instead of reduce?

Both combine a collection into a single value, but reduce starts from the first element and requires the result type to match the element type, while fold takes an explicit initial (seed) value and can therefore produce a different type. Two practical consequences: fold works on an empty collection (it returns the seed) whereas reduce throws on an empty collection because there is no first element, and fold lets you accumulate into something else entirely, like folding a list of strings into a single combined length Int. Reach for fold by default; reduce is a concise special case.

What is the difference between chunked and windowed?

chunked(n) splits a collection into consecutive, NON-overlapping pieces of size n, with the final piece possibly smaller — chunked(2) on [1,2,3,4,5] gives [[1,2],[3,4],[5]]. windowed(n) produces OVERLAPPING sliding windows of exactly size n that move one step at a time — windowed(2) on the same list gives [[1,2],[2,3],[3,4],[4,5]]. Use chunked to batch items (for example processing 100 records at a time) and windowed for neighbour comparisons like moving averages or detecting rising sequences.

What does flatMap do compared to map?

map { } applies a function to each element and returns a list of the same length — if the function returns a list, you end up with a list of lists. flatMap { } applies a function that returns a list for each element and then flattens the results by one level into a single list. So mapping [1,2] to listOf(it, it*10) gives [[1,10],[2,20]], while flatMap gives [1,10,2,20]. Use flatMap whenever each input expands into several outputs you want combined into one flat collection — for instance gathering all the tags across many posts.

How do sumOf and maxByOrNull differ from sum and max?

sum() and the older max() work directly on collections of numbers. sumOf { selector } first applies a selector to each element and sums those numbers, so you can sum a derived value like the length of each string without an intermediate map. maxByOrNull { selector } returns the ELEMENT whose selector value is largest (not the value itself), and returns null on an empty collection rather than throwing — which is why it replaced the older max-throwing variants. There is a matching minByOrNull, plus maxOf/minOf when you want the largest derived value rather than the element.