Collections

Introduction

Kotlin's collection types build directly on top of Java's existing collection framework — a List<String> in Kotlin is a real java.util.List underneath. What Kotlin adds is a crucial distinction Java lacks: separate read-only and mutable interfaces for every collection type, plus a rich set of functional operators for transforming data without writing manual loops.

This lesson covers List, Set, and Map, the read-only/mutable distinction, and the functional-style operators — map, filter, forEach, reduce, and sorting — that make working with collections in Kotlin dramatically more concise than in Java.

Read-Only vs Mutable Collections

Every collection type in Kotlin has two interfaces: a read-only one (List, Set, Map) that exposes no way to add, remove, or change elements, and a mutable one (MutableList, MutableSet, MutableMap) that does. This is a design-level safety feature, similar in spirit to val vs var — it lets you expose a collection to other code with a guarantee it cannot be modified.

fun main() {
    val readOnly: List<String> = listOf("Kotlin", "Java")
    val mutable: MutableList<String> = mutableListOf("Kotlin", "Java")

    // readOnly.add("Swift")   // Compile error: List has no add() method
    mutable.add("Swift")        // OK

    println(readOnly)
    println(mutable)
}

List

A List is an ordered collection that allows duplicate elements, accessed by index. listOf() creates a read-only list; mutableListOf() creates a mutable one.

fun main() {
    val fruits = listOf("Apple", "Banana", "Apple", "Cherry")

    println(fruits[0])          // indexed access
    println(fruits.size)
    println(fruits.contains("Banana"))
}

Set

A Set is an unordered collection that automatically discards duplicate elements. setOf() creates a read-only set; mutableSetOf() creates a mutable one.

fun main() {
    val uniqueNumbers = setOf(1, 2, 2, 3, 3, 3)
    println(uniqueNumbers)         // duplicates removed automatically
    println(uniqueNumbers.size)
}

Map

A Map stores key-value pairs with unique keys. mapOf() creates a read-only map; mutableMapOf() creates a mutable one. Kotlin's to infix function builds a Pair, which is the idiomatic way to write map entries.

fun main() {
    val ages = mapOf("Alice" to 30, "Bob" to 25)

    println(ages["Alice"])                 // 30
    println(ages["Unknown"])                // null — no exception
    println(ages.getOrDefault("Unknown", 0)) // 0

    for ((name, age) in ages) {
        println("$name is $age")
    }
}

Functional Operators: map, filter, forEach

Kotlin's standard library adds a large set of functional-style extension functions to every collection, letting you transform data declaratively instead of writing manual loops. map transforms each element, filter keeps only elements matching a condition, and forEach runs an action on each element.

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

    val doubled = numbers.map { it * 2 }
    val evens = numbers.filter { it % 2 == 0 }

    println(doubled)
    println(evens)

    evens.forEach { println("Even: $it") }
}

These operators can be chained fluently, since each one returns a new collection rather than mutating the original — numbers.filter { it % 2 == 0 }.map { it * it } reads almost like a sentence: "filter the numbers to evens, then square each one."

reduce and fold

reduce combines all elements of a collection into a single value by repeatedly applying an operation, using the first element as the starting accumulator. fold works the same way but lets you supply your own starting value, which also makes it safe to use on empty collections.

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

    val sum = numbers.reduce { acc, n -> acc + n }
    val sumWithBase = numbers.fold(100) { acc, n -> acc + n }

    println(sum)
    println(sumWithBase)
}

Sorting Collections

sorted() sorts elements using their natural order; sortedBy and sortedByDescending sort using a selector you provide, which is especially useful for sorting objects by a specific property.

data class Employee(val name: String, val salary: Int)

fun main() {
    val employees = listOf(
        Employee("Nina", 75000),
        Employee("Omar", 62000),
        Employee("Priya", 91000)
    )

    val bySalary = employees.sortedByDescending { it.salary }
    bySalary.forEach { println("${it.name}: ${it.salary}") }
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You can now store, transform, and query data confidently using Kotlin's List, Set, and Map types and its functional-style operators. Next, you'll learn two of Kotlin's most distinctive class types: data classes and sealed classes.