fold, reduce e runningFold
Agregue elementos de coleções com fold, reduce e funções de acumulação.
fold, reduce e runningFold é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.
Operações de agregação
fold e reduce agregam uma coleção em um único valor. fold aceita um valor inicial; reduce usa o primeiro elemento como valor inicial. runningFold retorna todos os resultados intermediários.
fold básico
fold(seed) { acc, x -> ... } começa com um valor inicial e combina cada elemento com o acumulador.
fun main() {
val nums = listOf(1, 2, 3, 4)
val sum = nums.fold(0) { acc, n -> acc + n }
println(sum) // 10
}fold com valor inicial não numérico
O valor inicial pode ser de qualquer tipo. fold pode converter List<T> em um 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 usa o primeiro elemento como valor inicial. A lambda combina dois elementos por vez.
fun main() {
val nums = listOf(2, 3, 4, 5)
val product = nums.reduce { acc, n -> acc * n }
println(product) // 120
}reduce lança uma exceção em listas vazias
reduce exige pelo menos um elemento. Use reduceOrNull por segurança ou prefira fold com um valor inicial.
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 versus reduce
Use fold quando precisar de um tipo de resultado diferente ou de um valor padrão. Use reduce quando o tipo do resultado for igual ao tipo dos elementos e a lista tiver pelo menos um 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 retorna uma lista com cada acumulador intermediário — útil para somas cumulativas e cadeias passo a passo.
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]
}Exemplo de soma cumulativa
Um padrão comum de análise: total cumulativo mês a mês.
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]
}Construção de um mapa com fold
Aplique fold a uma lista para criar um Map, acumulando os valores em um mapa mutável.
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)
}Construção de uma lista com fold
fold pode transformar uma sequência em uma lista estruturada — por exemplo, agrupando duplicatas consecutivas.
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
Passe o índice junto com cada elemento — útil para agregações que consideram a posição.
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 da direita para a esquerda. Isso importa quando a operação não é comutativa (por exemplo, na ordem de concatenação de strings).
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)
}Verificação rápida
Qual função retorna uma lista contendo todos os valores intermediários do acumulador?
Recapitulação
fold agrega com um valor inicial (de qualquer tipo). reduce usa o primeiro elemento como valor inicial (a coleção não pode estar vazia). runningFold / runningReduce retornam todos os valores intermediários. Use essas funções para somas, produtos, construção de mapas, agrupamentos e transformações passo a passo.
Aprenda Kotlin com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 51
- Aulas
- 203
Perguntas Frequentes
A aula “fold, reduce e runningFold” é grátis?
Sim — o texto completo de “fold, reduce e runningFold” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.
O que vou aprender em “fold, reduce e runningFold”?
Agregue elementos de coleções com fold, reduce e funções de acumulação. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Kotlin Academy?
Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “fold, reduce e runningFold”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Kotlin Academy?
Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- map e flatMap: transformando cada elemento
- filter, filterNot e partition
- fold, reduce e runningFold
- Encadeando pipelines e evitando listas intermediárias com Sequence