fold, reduce et runningFold
Agrégerez les éléments d’une collection avec fold, reduce et des fonctions d’accumulation.
fold, reduce et runningFold est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.
Opérations d’agrégation
fold et la réduction agrègent une collection en une seule valeur. fold accepte une valeur initiale ; la réduction utilise le premier élément comme valeur initiale. runningFold renvoie chaque résultat intermédiaire.
fold de base
fold(seed) { acc, x -> ... } commence par une valeur initiale et combine chaque élément avec l’accumulateur.
fun main() {
val nums = listOf(1, 2, 3, 4)
val sum = nums.fold(0) { acc, n -> acc + n }
println(sum) // 10
}fold avec une valeur initiale non numérique
La valeur initiale peut être de n’importe quel type. fold peut convertir List<T> en un résultat totalement différent.
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
}Réduction de base
reduce utilise le premier élément comme valeur initiale. La lambda combine deux éléments à la fois.
fun main() {
val nums = listOf(2, 3, 4, 5)
val product = nums.reduce { acc, n -> acc * n }
println(product) // 120
}La réduction échoue sur les listes vides
reduce nécessite au moins un élément. Utilisez reduceOrNull par sécurité, ou préférez fold avec une valeur initiale.
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 contre réduction
Utilisez fold lorsque vous avez besoin d’un type de résultat différent ou d’une valeur par défaut. Utilisez la réduction lorsque le type de résultat correspond à celui des éléments et que la liste contient au moins un élément.
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 renvoie une liste de chaque accumulateur intermédiaire, ce qui est pratique pour les sommes cumulées et les chaînes de traitement étape par étape.
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]
}Exemple de somme cumulée
Un modèle courant en analyse : le total cumulé d’un mois sur l’autre.
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]
}Construire une carte avec fold
Pliez une liste dans une Map en accumulant les valeurs dans une carte modifiable.
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)
}Construire une liste avec fold
fold peut transformer une séquence en une liste structurée, par exemple pour regrouper les doublons consécutifs.
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
Transmettez l’index avec chaque élément, ce qui est utile pour les agrégations tenant compte de la position.
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 agrège de droite à gauche. Cela compte lorsque l’opération n’est pas commutative, par exemple pour l’ordre de concaténation des chaînes.
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)
}Vérification rapide
Quelle fonction renvoie une liste contenant chaque valeur intermédiaire de l’accumulateur ?
Récapitulatif
fold agrège avec une valeur initiale (de n’importe quel type). La réduction utilise le premier élément comme valeur initiale (la collection doit être non vide). runningFold / runningReduce renvoient chaque valeur intermédiaire. Utilisez-les pour les sommes, les produits, la construction de cartes, le regroupement et les transformations étape par étape.
Questions Fréquemment Posées
La leçon « fold, reduce et runningFold » est-elle gratuite ?
Oui — le texte complet de « fold, reduce et runningFold » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « fold, reduce et runningFold » ?
Agrégerez les éléments d’une collection avec fold, reduce et des fonctions d’accumulation. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Kotlin Academy ?
Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « fold, reduce et runningFold » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?
Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- map et flatMap : transformer chaque élément
- filter, filterNot et partition
- fold, reduce et runningFold
- Enchaîner des pipelines et éviter les listes intermédiaires avec Sequence