0Pricing
Kotlin Academy · Lektion

fold, reduce und runningFold

Aggregieren Sie Collection-Elemente mit fold, reduce und Akkumulationsfunktionen.

fold, reduce und runningFold ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Aggregationsoperationen

fold und reduce aggregieren eine Collection zu einem einzelnen Wert. fold akzeptiert einen Startwert; reduce verwendet das erste Element als Startwert. runningFold gibt jedes Zwischenergebnis zurück.

Einfaches fold

fold(seed) { acc, x -> ... } beginnt mit einem Startwert und kombiniert jedes Element mit dem Akkumulator.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    val sum = nums.fold(0) { acc, n -> acc + n }
    println(sum) // 10
}

fold mit einem nicht numerischen Startwert

Der Startwert kann einen beliebigen Typ haben. fold kann List<T> in ein völlig anderes Ergebnis umwandeln.

fun main() {
    val words = listOf("hello", "world", "kotlin")
    val joined = words.fold("") { acc, w -> if (acc.isEmpty()) w else "$acc, $w" }
    println(joined) // hello, world, kotlin
}

Einfaches reduce

reduce verwendet das erste Element als Startwert. Die Lambda-Funktion kombiniert jeweils zwei Elemente.

fun main() {
    val nums = listOf(2, 3, 4, 5)
    val product = nums.reduce { acc, n -> acc * n }
    println(product) // 120
}

reduce schlägt bei leeren Listen fehl

reduce benötigt mindestens ein Element. Verwenden Sie für mehr Sicherheit reduceOrNull oder bevorzugen Sie fold mit einem Startwert.

fun main() {
    val empty: List<Int> = emptyList()
    println(empty.reduceOrNull { a, b -> a + b }) // null
    println(empty.fold(0) { a, b -> a + b })       // 0
}

fold vs. reduce

Verwenden Sie fold, wenn Sie einen anderen Ergebnistyp oder einen Standardwert benötigen. Verwenden Sie reduce, wenn der Ergebnistyp dem Elementtyp entspricht und die Liste mindestens ein Element enthält.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    println(nums.reduce { a, b -> a + b })       // 10
    println(nums.fold(100) { a, b -> a + b })   // 110 (seed 100)
}

runningFold

runningFold gibt eine Liste mit jedem Zwischenstand des Akkumulators zurück – praktisch für kumulative Summen und schrittweise Pipelines.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    val running = nums.runningFold(0) { acc, n -> acc + n }
    println(running) // [0, 1, 3, 6, 10]
}

Beispiel für eine kumulative Summe

Ein häufiges Muster in der Analyse: die kumulative Gesamtsumme von Monat zu Monat.

fun main() {
    val monthly = listOf(100, 150, 80, 200, 120)
    val cumulative = monthly.runningReduce { acc, x -> acc + x }
    println(cumulative) // [100, 250, 330, 530, 650]
}

Mit fold eine Map erstellen

Aggregieren Sie eine Liste mit fold zu einer Map, indem Sie die Werte in einer veränderlichen Map sammeln.

fun main() {
    val words = listOf("apple", "banana", "cherry")
    val byLetter = words.fold(mutableMapOf<Char, MutableList<String>>()) { acc, w ->
        val key = w[0]
        acc.getOrPut(key) { mutableListOf() }.add(w)
        acc
    }
    println(byLetter)
}

Mit fold eine Liste erstellen

fold kann eine Sequenz in eine strukturierte Liste umwandeln – zum Beispiel, indem aufeinanderfolgende Duplikate gruppiert werden.

fun main() {
    val nums = listOf(1, 1, 2, 3, 3, 3, 4)
    val grouped = nums.fold(mutableListOf<MutableList<Int>>()) { acc, n ->
        if (acc.isEmpty() || acc.last().last() != n) acc.add(mutableListOf(n))
        else acc.last().add(n)
        acc
    }
    println(grouped) // [[1, 1], [2], [3, 3, 3], [4]]
}

foldIndexed

Übergeben Sie zusammen mit jedem Element auch den Index – nützlich für positionsabhängige Aggregationen.

fun main() {
    val nums = listOf(10, 20, 30)
    val weighted = nums.foldIndexed(0) { i, acc, n -> acc + (i + 1) * n }
    // 1*10 + 2*20 + 3*30 = 140
    println(weighted)
}

reduceRight

reduceRight aggregiert von rechts nach links. Das ist wichtig, wenn die Operation nicht kommutativ ist (zum Beispiel bei der Reihenfolge von Zeichenkettenverkettungen).

fun main() {
    val words = listOf("a", "b", "c", "d")
    val leftToRight = words.reduce { acc, w -> "$acc-$w" }
    val rightToLeft = words.reduceRight { w, acc -> "$w-$acc" }
    println(leftToRight)   // a-b-c-d
    println(rightToLeft)   // a-b-c-d (same here but operation matters)
}

Kurze Überprüfung

Welche Funktion gibt eine Liste mit jedem Zwischenwert des Akkumulators zurück?

Zusammenfassung

fold aggregiert mit einem Startwert (beliebiger Typ). reduce verwendet das erste Element als Startwert (die Collection darf nicht leer sein). runningFold und runningReduce geben jeden Zwischenwert zurück. Verwenden Sie diese Funktionen für Summen, Produkte, das Erstellen von Maps, Gruppierungen und schrittweise Transformationen.

Häufig gestellte Fragen

Ist die Lektion „fold, reduce und runningFold“ kostenlos?

Ja — der vollständige Text von „fold, reduce und runningFold“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „fold, reduce und runningFold“?

Aggregieren Sie Collection-Elemente mit fold, reduce und Akkumulationsfunktionen. Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „fold, reduce und runningFold“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. map und flatMap: Jedes Element umwandeln
  2. filter, filterNot und partition
  3. fold, reduce und runningFold
  4. Pipelines verketten und Zwischenlisten mit Sequence vermeiden
← Zurück zu Kotlin Academy