Kotlin collections and higher-order functions

Filter, map, group, sort, and fold lists with lambdas instead of loops.

data class Person(val name: String, val age: Int, val city: String)

fun main() {
    val people = listOf(
        Person("Ada", 36, "London"),
        Person("Bo", 25, "Paris"),
        Person("Cy", 41, "London"),
        Person("Di", 25, "Paris"),
    )

    println(people.filter { it.age > 30 }.map { it.name })
    println(people.groupBy { it.city }.mapValues { (_, list) -> list.size })
    println(people.sumOf { it.age })
    println(people.sortedWith(compareBy({ it.age }, { it.name })).map { it.name })
    println(people.maxByOrNull { it.age }?.name)
    println(people.partition { it.city == "London" }.let { (london, others) -> london.size to others.size })
    println((1..5).fold(1) { product, n -> product * n })
}

[Ada, Cy]
{London=2, Paris=2}
127
[Bo, Di, Ada, Cy]
Cy
(2, 2)
120

Explanation

Kotlin's standard library offers many functions that take a lambda and work on a whole collection. filter keeps matching elements, map transforms each element, and groupBy splits a list into a map by a key. sumOf adds up a computed value, partition splits a list into two by a condition, and fold combines all elements into one value starting from an initial value. Inside a lambda with one parameter, the implicit name it refers to the element.

These functions return new collections and leave the original unchanged. sortedWith(compareBy(...)) sorts by several keys, with later keys breaking ties, and the sort is stable. Chaining operations produces a short, readable pipeline, though each step creates a new list, so for very large data Sequences evaluate lazily to avoid the intermediate lists.

[Ada, Cy]

[Ada, Cy]
{London=2, Paris=2}

[Ada, Cy]
{London=2, Paris=2}
127

[Ada, Cy]
{London=2, Paris=2}
127
[Bo, Di, Ada, Cy]

[Ada, Cy]
{London=2, Paris=2}
127
[Bo, Di, Ada, Cy]
Cy

[Ada, Cy]
{London=2, Paris=2}
127
[Bo, Di, Ada, Cy]
Cy
(2, 2)

[Ada, Cy]
{London=2, Paris=2}
127
[Bo, Di, Ada, Cy]
Cy
(2, 2)
120

Cost and common mistakes

Each pipeline step is O(n); sorting is O(n log n).

• maxByOrNull is the safe version. maxBy (older versions) throws on an empty collection.
• Long chains create intermediate lists. For large inputs start with asSequence() to process one element at a time.
• groupBy keeps the original order of elements inside each group.

Try it yourself

How would you list the names sorted by age descending?

Further reading

• Kotlin documentation (external)
• Kotlin standard library (external)