Kotlin Academy · Lección

Sequences frente a colecciones

Cuándo conviene cada una

Sequences frente a colecciones es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 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.

Secuencias frente a colecciones

Tanto las secuencias como las colecciones ofrecen las mismas operaciones funcionales, pero las evalúan de forma diferente. Saber cuándo conviene cada una le ayudará a escribir código eficiente y fácil de leer.

Resumen de las colecciones de evaluación inmediata

Las colecciones utilizan una evaluación inmediata: cada operación procesa todos los elementos y produce una colección nueva de inmediato. Esto resulta sencillo y rápido con pocos datos.

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

Resumen de las secuencias perezosas

Las secuencias son perezosas: las operaciones construyen un pipeline que se ejecuta elemento por elemento solo cuando se consume, evitando las colecciones intermedias.

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

Cuándo ganan las colecciones

Para colecciones pequeñas y cadenas cortas, las colecciones suelen ser más rápidas y claras. Las secuencias añaden sobrecarga por elemento, como las llamadas al iterador, que puede superar sus beneficios con cantidades minúsculas de datos.

Cuándo ganan las secuencias

Las secuencias son mejores cuando los datos son grandes, la cadena es larga o solo necesita una parte del resultado, como la primera coincidencia o los primeros N elementos. Evitan crear listas intermedias grandes y se detienen antes.

fun main() {
    val firstEvenSquare = (1..1000000).asSequence()
        .map { it * it }
        .first { it % 2 == 0 }
    println(firstEvenSquare)
}

Medir la diferencia

Este ejemplo con un rango grande muestra cómo una secuencia evita producir una lista intermedia de un millón de elementos que la versión de evaluación inmediata crearía.

fun main() {
    val seqResult = (1..1000).asSequence()
        .filter { it % 2 == 0 }
        .map { it * 3 }
        .take(3)
        .toList()
    println(seqResult)
}

Huella de memoria

Las cadenas de evaluación inmediata mantienen todas las listas intermedias en memoria al mismo tiempo. Las secuencias solo mantienen el elemento actual mientras recorre el pipeline, por lo que el uso máximo de memoria se mantiene bajo incluso en pipelines largos.

Ventaja de la terminación anticipada

Si una operación terminal puede finalizar antes, como first, find o any, las secuencias omiten los elementos restantes, mientras que las colecciones de evaluación inmediata ya los habrían procesado todos.

fun main() {
    val found = (1..100).asSequence()
        .map { println("checking $it"); it }
        .any { it == 3 }
    println("Found: $found")
}

Cuidado con las operaciones con estado

Las operaciones como sorted, distinct y groupBy necesitan todos los elementos, por lo que reducen la ventaja de la evaluación perezosa. Un pipeline dominado por estas operaciones podría no beneficiarse de una secuencia.

Una pauta práctica

Como regla general, utilice colecciones por defecto para mantener la claridad. Cambie a una secuencia cuando procese datos grandes, encadene muchas operaciones o solo necesite una pequeña parte del resultado. Mida siempre el rendimiento si este es crítico.

Misma API, distinto motor

Como ambas comparten los mismos nombres de operación, normalmente puede cambiar de una a otra añadiendo o eliminando asSequence() y una operación terminal toList(). Esto permite experimentar con el rendimiento con poco riesgo.

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

Comprobación rápida

¿En qué situación es más probable que una secuencia supere el rendimiento de una colección?

Resumen

Las colecciones utilizan una evaluación inmediata y son mejores para pocos datos y para mantener la claridad; las secuencias son perezosas y son mejores para datos grandes, cadenas largas o resultados parciales, gracias a que no crean listas intermedias y permiten la terminación anticipada. Tenga cuidado con las operaciones con estado. Comparten la misma API, por lo que cambiar de una a otra es sencillo. Con esto termina el curso de Secuencias.

Preguntas frecuentes

¿La lección «Sequences frente a colecciones» es gratis?

Sí — el texto completo de «Sequences frente a colecciones» 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 «Sequences frente a colecciones»?

Cuándo conviene cada una 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 4 de 4.

¿Cuánto tiempo toma la lección «Sequences frente a colecciones»?

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