fold, reduce y runningFold
Agregue elementos de colecciones con fold, reduce y funciones de acumulación.
fold, reduce y runningFold es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.
Operaciones de agregación
fold y reduce agregan una colección en un único valor. fold acepta una semilla; reduce utiliza el primer elemento como semilla. runningFold devuelve cada resultado intermedio.
fold básico
fold(seed) { acc, x -> ... } comienza con una semilla y combina cada elemento con el acumulador.
fun main() {
val nums = listOf(1, 2, 3, 4)
val sum = nums.fold(0) { acc, n -> acc + n }
println(sum) // 10
}fold con una semilla no numérica
La semilla puede ser de cualquier tipo. fold puede convertir List<T> en un resultado completamente diferente.
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
}reduce básico
reduce utiliza el primer elemento como semilla. La lambda combina dos elementos cada vez.
fun main() {
val nums = listOf(2, 3, 4, 5)
val product = nums.reduce { acc, n -> acc * n }
println(product) // 120
}reduce produce una excepción en listas vacías
reduce requiere al menos un elemento. Utilice reduceOrNull para mayor seguridad o prefiera fold con una semilla.
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 frente a reduce
Utilice fold cuando necesite un tipo de resultado diferente o un valor predeterminado. Utilice reduce cuando el tipo de resultado coincida con el tipo de los elementos y la lista contenga al menos un elemento.
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 devuelve una lista con cada acumulador intermedio; resulta práctico para sumas acumuladas y pipelines paso a paso.
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]
}Ejemplo de suma acumulada
Un patrón habitual de analítica: total acumulado mes a mes.
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]
}Crear un Map con fold
Agregue una lista en un Map mediante un mapa mutable como acumulador.
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)
}Crear una lista con fold
fold puede transformar una secuencia en una lista estructurada; por ejemplo, puede agrupar duplicados consecutivos.
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
Pase el índice junto con cada elemento; resulta útil para agregaciones que tienen en cuenta la posición.
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 agrega de derecha a izquierda. Esto es importante cuando la operación no es conmutativa (por ejemplo, en el orden de concatenación de cadenas).
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)
}Comprobación rápida
¿Qué función devuelve una lista que contiene cada valor intermedio del acumulador?
Resumen
fold agrega con una semilla (de cualquier tipo). reduce utiliza el primer elemento como semilla (la colección no puede estar vacía). runningFold y runningReduce devuelven cada valor intermedio. Utilice estas funciones para sumas, productos, creación de mapas, agrupaciones y transformaciones paso a paso.
Aprende Kotlin con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 51
- Lecciones
- 203
Preguntas frecuentes
¿La lección «fold, reduce y runningFold» es gratis?
Sí — el texto completo de «fold, reduce y runningFold» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.
¿Qué aprenderé en «fold, reduce y runningFold»?
Agregue elementos de colecciones con fold, reduce y funciones de acumulación. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Kotlin Academy?
No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «fold, reduce y runningFold»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?
Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- map y flatMap: transformar cada elemento
- filter, filterNot y partition
- fold, reduce y runningFold
- Encadenar pipelines y evitar listas intermedias con Sequence