Operações Tardias
Evite listas intermediárias
Operações Tardias é 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 preguiçosas
O poder das sequências vem das operações preguiçosas. As operações intermediárias constroem um fluxo de processamento sem executá-lo, e somente uma operação terminal faz os elementos avançarem por ele. Isso evita listas intermediárias.
Sem listas intermediárias
Com coleções, cada map e filter aloca uma nova lista. Com sequências, os elementos passam por todas as etapas sem criar essas listas temporárias.
fun main() {
val result = (1..6).asSequence()
.map { it * it }
.filter { it % 2 == 0 }
.toList()
println(result)
}Observando a avaliação preguiçosa
Sem uma operação terminal, nenhuma das funções lambda é executada. O fluxo de processamento é apenas uma receita até ser consumido.
fun main() {
val pipeline = (1..3).asSequence()
.map { println("map $it"); it }
println("Built pipeline, nothing ran")
pipeline.toList()
}take limita o trabalho
take(n) é uma operação intermediária preguiçosa. Combinada com um gerador infinito, ela para depois de produzir n elementos.
fun main() {
val firstThree = generateSequence(1) { it + 1 }
.map { it * 10 }
.take(3)
.toList()
println(firstThree)
}first interrompe antecipadamente
Operações terminais como first param assim que obtêm o que precisam, ignorando completamente os demais elementos.
fun main() {
val result = (1..1000).asSequence()
.map { println("processing $it"); it }
.first { it > 3 }
println("Found $result")
}Processamento elemento a elemento
Em uma sequência, o elemento 1 passa por map e depois por filter; em seguida, o elemento 2 passa pelas mesmas etapas, e assim por diante. Essa ordem permite a interrupção antecipada e evita armazenar todos os resultados em memória.
fun main() {
listOf(1, 2, 3, 4).asSequence()
.filter { println("filter $it"); it % 2 == 0 }
.map { println("map $it"); it * 10 }
.toList()
}takeWhile e dropWhile
takeWhile produz elementos até que o predicado falhe; dropWhile ignora os elementos iniciais enquanto o predicado for satisfeito. Ambas são preguiçosas.
fun main() {
val nums = generateSequence(1) { it + 1 }
println(nums.takeWhile { it < 5 }.toList())
}Evitando computação desperdiçada
Como nada é executado até ser consumido e o consumo pode parar antecipadamente, transformações custosas são aplicadas apenas aos elementos que realmente chegam a uma operação terminal.
fun main() {
val result = (1..100).asSequence()
.map { it * 2 }
.filter { it > 10 }
.take(2)
.toList()
println(result)
}Reutilizando sequências
A maioria das sequências pode ser percorrida várias vezes, executando novamente o fluxo de processamento a cada vez. Porém, sequências provenientes de fontes de uso único, como um iterador, podem ser consumidas apenas uma vez. Tenha atenção à fonte.
fun main() {
val seq = sequenceOf(1, 2, 3).map { it * 2 }
println(seq.toList())
println(seq.sum())
}Operações com estado e sem estado
A maioria das operações não tem estado, pois processa um elemento de cada vez. Algumas, como sorted ou distinct, têm estado e precisam armazenar ou percorrer todos os elementos, reduzindo o benefício da avaliação preguiçosa.
fun main() {
val result = sequenceOf(3, 1, 2, 1).distinct().sorted().toList()
println(result)
}Os benefícios da avaliação preguiçosa
As operações preguiçosas economizam memória ao evitar listas intermediárias e economizam tempo ao interromper o processamento antecipadamente. Quanto maiores forem os dados e mais seletiva for a operação terminal, maior será o benefício.
Verificação rápida
Quando as funções lambda de uma cadeia de sequências são realmente executadas?
Recapitulação
As operações preguiçosas constroem um fluxo de processamento que só é executado quando uma operação terminal o consome, evitando listas intermediárias e permitindo a interrupção antecipada com first, take e takeWhile. Tenha cuidado com operações que têm estado, como sorted. Em seguida, você decidirá quando as sequências são melhores que as coleções.
Perguntas Frequentes
A aula “Operações Tardias” é grátis?
Sim — o texto completo de “Operações Tardias” é 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 “Operações Tardias”?
Evite listas intermediárias 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 “Operações Tardias”?
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.