0Pricing
Kotlin Academy · Lekcja

fold, reduce i runningFold

Agreguj elementy kolekcji za pomocą fold, reduce i funkcji akumulujących.

fold, reduce i runningFold to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Operacje agregacji

fold i reduce agregują kolekcję do jednej wartości. fold przyjmuje wartość początkową, a reduce używa jako niej pierwszego elementu. runningFold zwraca każdy wynik pośredni.

Podstawowe fold

fold(seed) { acc, x -> ... } rozpoczyna od wartości początkowej i łączy każdy element z akumulatorem.

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

fold z nieliczbową wartością początkową

Wartość początkowa może mieć dowolny typ. fold może przekształcić List<T> w całkowicie inny wynik.

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
}

Podstawowe reduce

reduce używa pierwszego elementu jako wartości początkowej. Lambda łączy po dwa elementy naraz.

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

reduce zgłasza wyjątek dla pustych list

reduce wymaga co najmniej jednego elementu. Dla bezpieczeństwa należy użyć reduceOrNull albo wybrać fold z wartością początkową.

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 a reduce

Należy używać fold, gdy potrzebny jest inny typ wyniku lub wartość domyślna. reduce należy stosować, gdy typ wyniku odpowiada typowi elementów, a lista zawiera co najmniej jeden element.

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 zwraca listę zawierającą każdy pośredni stan akumulatora — przydaje się do sum skumulowanych i potoków wykonywanych krok po kroku.

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]
}

Przykład sumy skumulowanej

Typowy wzorzec analityczny: skumulowana suma zmieniająca się z miesiąca na miesiąc.

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]
}

Budowanie Map za pomocą fold

Można zwinąć listę do obiektu Map, akumulując dane w mutowalnej mapie.

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)
}

Budowanie listy za pomocą fold

fold może przekształcić sekwencję w uporządkowaną listę — na przykład grupując kolejne powtórzenia.

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

Przekazuje indeks wraz z każdym elementem — przydatne podczas agregacji uwzględniającej pozycję.

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 agreguje elementy od prawej do lewej. Ma to znaczenie, gdy operacja nie jest przemienna, na przykład w przypadku kolejności konkatenacji ciągów znaków.

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)
}

Szybkie sprawdzenie

Która funkcja zwraca listę zawierającą każdą pośrednią wartość akumulatora?

Podsumowanie

fold agreguje elementy z użyciem wartości początkowej (dowolnego typu). reduce używa jako wartości początkowej pierwszego elementu (lista nie może być pusta). runningFold / runningReduce zwracają każdą wartość pośrednią. Operacje te służą do obliczania sum i iloczynów, budowania map, grupowania oraz przekształceń wykonywanych krok po kroku.

Często zadawane pytania

Czy lekcja „fold, reduce i runningFold” jest bezpłatna?

Tak — pełny tekst „fold, reduce i runningFold” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „fold, reduce i runningFold”?

Agreguj elementy kolekcji za pomocą fold, reduce i funkcji akumulujących. Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „fold, reduce i runningFold”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. map i flatMap: przekształcanie każdego elementu
  2. filter, filterNot i partition
  3. fold, reduce i runningFold
  4. Łańcuchy potoków i unikanie list pośrednich za pomocą Sequence
← Powrót do Kotlin Academy