Kotlin Academy · Lección

Por qué usar sequences

Evaluación perezosa

Por qué usar sequences es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 1 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.

¿Qué son las secuencias?

Una Sequence es similar a una colección, pero procesa los elementos de forma perezosa. Las operaciones no se ejecutan hasta que una operación terminal solicita los resultados, y los elementos recorren toda la cadena de uno en uno.

Colecciones eager

Las operaciones de colecciones estándar son eager: cada paso (filter, map) procesa completamente la lista y crea una nueva lista intermedia antes de que comience el siguiente paso.

fun main() {
    val result = listOf(1, 2, 3, 4)
        .map { it * 2 }
        .filter { it > 4 }
    println(result)
}

El coste de las listas intermedias

Con datos grandes, el procesamiento eager asigna una nueva lista en cada paso. Con muchas operaciones o millones de elementos, esto desperdicia memoria y tiempo.

Secuencias perezosas

Una secuencia procesa cada elemento a través de toda la canalización antes de pasar al siguiente. No se crean listas intermedias. Puede convertir una colección con asSequence().

fun main() {
    val result = listOf(1, 2, 3, 4)
        .asSequence()
        .map { it * 2 }
        .filter { it > 4 }
        .toList()
    println(result)
}

Observar el orden de ejecución

Agregar impresiones permite ver la diferencia. Con una secuencia, cada elemento pasa por map y después por filter antes de que comience el procesamiento del siguiente elemento.

fun main() {
    listOf(1, 2, 3).asSequence()
        .map { println("map $it"); it * 2 }
        .filter { println("filter $it"); it > 2 }
        .toList()
}

Orden de ejecución eager

Compárelo con una lista normal: map se ejecuta primero para TODOS los elementos y, después, filter se ejecuta para todos ellos.

fun main() {
    listOf(1, 2, 3)
        .map { println("map $it"); it * 2 }
        .filter { println("filter $it"); it > 2 }
}

Ejecución con cortocircuito

La evaluación perezosa permite ejecutar con cortocircuito: operaciones como first o find se detienen en cuanto encuentran un resultado y evitan procesar el resto.

fun main() {
    val firstBig = (1..1000000).asSequence()
        .map { it * 2 }
        .first { it > 10 }
    println(firstBig)
}

Operaciones intermedias y terminales

Las operaciones de las secuencias se dividen en dos tipos:

Intermedias (map, filter, take): son perezosas y devuelven otra secuencia.
Terminales (toList, sum, first): activan el cálculo y producen un valor.

Sin una operación terminal no ocurre nada

Una cadena formada únicamente por operaciones intermedias no ejecuta ningún código. Las lambdas no se ejecutan hasta que se llama a una operación terminal.

fun main() {
    val seq = listOf(1, 2, 3).asSequence()
        .map { println("processing $it"); it }
    println("Nothing printed yet")
    seq.toList()
}

Cuándo ayudan las secuencias

Las secuencias son especialmente útiles con conjuntos de datos grandes, cadenas largas de operaciones o cuando solo necesita una parte del resultado, como la primera coincidencia. Para listas pequeñas, las colecciones normales son más sencillas e igual de rápidas.

Una representación mental

Imagine que una colección procesa los datos en capas horizontales (todos los elementos en cada paso), mientras que una secuencia los procesa en flujos verticales (un elemento a través de todos los pasos). Por eso las secuencias evitan las listas intermedias.

Comprobación rápida

¿Por qué pueden ser más eficientes las secuencias que las colecciones?

Repaso

Las secuencias procesan los datos de forma perezosa, elemento por elemento, a través de una cadena de operaciones intermedias, y el cálculo solo se activa mediante una operación terminal. Esto evita las listas intermedias y permite la ejecución con cortocircuito. A continuación, aprenderá a crear secuencias.

Preguntas frecuentes

¿La lección «Por qué usar sequences» es gratis?

Sí — el texto completo de «Por qué usar sequences» 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 «Por qué usar sequences»?

Evaluación perezosa 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 1 de 4.

¿Cuánto tiempo toma la lección «Por qué usar sequences»?

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

← Volver a Kotlin Academy