Operaciones perezosas
Evite las listas intermedias
Operaciones perezosas 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 perezosas
El poder de las secuencias proviene de las operaciones perezosas. Las operaciones intermedias construyen un pipeline sin ejecutarlo, y solo una operación terminal hace que los elementos lo recorran. Así se evitan las listas intermedias.
Sin listas intermedias
Con las colecciones, cada operación map y filter crea una lista nueva. Con las secuencias, los elementos pasan por todos los pasos sin crear esas listas temporales.
fun main() {
val result = (1..6).asSequence()
.map { it * it }
.filter { it % 2 == 0 }
.toList()
println(result)
}Observar la evaluación perezosa
Sin una operación terminal, ninguna lambda se ejecuta. El pipeline es solo una receta hasta que se consume.
fun main() {
val pipeline = (1..3).asSequence()
.map { println("map $it"); it }
println("Built pipeline, nothing ran")
pipeline.toList()
}take limita el trabajo
take(n) es una operación intermedia perezosa. Al combinarla con un generador infinito, se detiene después de producir n elementos.
fun main() {
val firstThree = generateSequence(1) { it + 1 }
.map { it * 10 }
.take(3)
.toList()
println(firstThree)
}first detiene el procesamiento
Las operaciones terminales como first se detienen en cuanto obtienen lo que necesitan y omiten por completo el resto de los elementos.
fun main() {
val result = (1..1000).asSequence()
.map { println("processing $it"); it }
.first { it > 3 }
println("Found $result")
}Procesamiento elemento por elemento
En una secuencia, el elemento 1 pasa por map y luego por filter; después lo hace el elemento 2, y así sucesivamente. Este orden permite la terminación anticipada y evita almacenar en búfer todos los resultados.
fun main() {
listOf(1, 2, 3, 4).asSequence()
.filter { println("filter $it"); it % 2 == 0 }
.map { println("map $it"); it * 10 }
.toList()
}takeWhile y dropWhile
takeWhile produce elementos hasta que el predicado deja de cumplirse; dropWhile omite los elementos iniciales mientras el predicado se cumpla. Ambas son perezosas.
fun main() {
val nums = generateSequence(1) { it + 1 }
println(nums.takeWhile { it < 5 }.toList())
}Evitar cálculos innecesarios
Como nada se ejecuta hasta que se consume y el consumo puede detenerse antes de tiempo, las transformaciones costosas solo se aplican a los elementos que realmente llegan a una operación terminal.
fun main() {
val result = (1..100).asSequence()
.map { it * 2 }
.filter { it > 10 }
.take(2)
.toList()
println(result)
}Reutilizar secuencias
La mayoría de las secuencias se pueden recorrer varias veces, volviendo a ejecutar el pipeline cada vez. Sin embargo, las secuencias procedentes de fuentes de un solo uso, como un iterador, solo se pueden consumir una vez. Tenga en cuenta la fuente.
fun main() {
val seq = sequenceOf(1, 2, 3).map { it * 2 }
println(seq.toList())
println(seq.sum())
}Operaciones con estado frente a operaciones sin estado
La mayoría de las operaciones no tienen estado: procesan un elemento cada vez. Algunas, como sorted o distinct, tienen estado y deben almacenar en búfer o recorrer todos los elementos, lo que reduce la ventaja de la evaluación perezosa.
fun main() {
val result = sequenceOf(3, 1, 2, 1).distinct().sorted().toList()
println(result)
}Las ventajas de la evaluación perezosa
Las operaciones perezosas ahorran memoria al omitir las listas intermedias y ahorran tiempo al detener el procesamiento antes de tiempo. Cuanto mayores sean los datos y más selectiva sea la operación terminal, mayor será el beneficio.
Comprobación rápida
¿Cuándo se ejecutan realmente las lambdas de una cadena de secuencias?
Resumen
Las operaciones perezosas construyen un pipeline que solo se ejecuta cuando una operación terminal lo consume, evitando las listas intermedias y permitiendo la terminación anticipada con first, take y takeWhile. Tenga cuidado con las operaciones con estado, como sorted. A continuación, decidirá cuándo las secuencias son mejores que las colecciones.
Preguntas frecuentes
¿La lección «Operaciones perezosas» es gratis?
Sí — el texto completo de «Operaciones perezosas» 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 «Operaciones perezosas»?
Evite las listas intermedias 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 «Operaciones perezosas»?
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
- Por qué usar sequences
- Creación de sequences
- Operaciones perezosas
- Sequences frente a colecciones