¿Cómo trabajar con flujos (streams) en Kotlin?

En Kotlin, para trabajar con flujos de datos (equivalente a Java 8 Streams API), se utilizan funciones de extensión para colecciones proporcionadas por la biblioteca de funciones estándar. No es una API separada, sino un conjunto de métodos en kotlin.collections.

Las operaciones principales con flujos se dividen en:

• Operaciones intermedias: Devuelven una nueva colección y son "perezosas" (se ejecutan solo al llamar a una operación terminal). Ejemplos: filter, map, flatMap, distinct, sorted, take, drop.
• Operaciones terminales: Finalizan la secuencia de operaciones y devuelven un resultado (no una colección). Disparan la ejecución de todas las operaciones intermedias. Ejemplos: forEach, reduce, fold, count, sum, average, min, max, toList, toSet, toMap.

También existe el concepto de secuencias (sequences), que proporciona una pereza explícita. Las secuencias procesan los elementos uno a uno según sea necesario, lo que puede ser más eficiente para colecciones grandes o cadenas largas de operaciones:

• Crear una secuencia: collection.asSequence()
• Convertir de nuevo a colección: sequence.toList()

// Ejemplo de uso de funciones estándar para procesamiento en flujo
fun processCollection() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val evenSquares = numbers
        .filter { it % 2 == 0 } // Operación intermedia: filtramos números pares
        .map { it * it }     // Operación intermedia: elevamos al cuadrado

    println(evenSquares) // Operación terminal: mostramos la colección (ejecuta filter y map)

    val sumOfOdd = numbers
        .filter { it % 2 != 0 } // Intermedia
        .sum()                // Terminal (calcula la suma de los impares)

    println(sumOfOdd)
}

// Ejemplo de uso de secuencias
fun processSequence() {
    val largeCollection = (1..1_000_000).toList()

    // Con colecciones (no perezosas): filter y map se ejecutan para todos los elementos de inmediato
    val resultCollection = largeCollection
        .filter { it % 2 == 0 }
        .map { it * 2 }
        .take(10) // take(10) se ejecuta después de filter y map para todos

    println("Resultado colección tamaño: ${resultCollection.size}")

    // Con secuencias (perezosas): filter, map y take se ejecutan elemento por elemento
    val resultSequence = largeCollection.asSequence()
        .filter { it % 2 == 0 } // filter se ejecuta para cada elemento en orden
        .map { it * 2 }     // map se ejecuta para cada elemento que pasa el filtro
        .take(10)         // take(10) detiene el procesamiento después de 10 elementos

    println("Resultado secuencia tamaño: ${resultSequence.toList().size}") // toList() dispara la ejecución de la secuencia
}

fun main() {
    processCollection()
    processSequence()
}

Tabla comparativa de funciones estándar y secuencias respecto a la pereza:

Característica	Funciones estándar de colecciones	Secuencias
Pereza	Pereza implícita en operaciones intermedias, pero la operación terminal procesa toda la cadena intermedia	Pereza explícita: las operaciones se ejecutan elemento por elemento según sea necesario
Eficiencia	Puede ser menos eficiente para colecciones grandes y cadenas largas de operaciones debido a colecciones intermedias	Más eficiente para colecciones grandes y cadenas largas de operaciones
Aplicación	Adecuado para colecciones pequeñas y medianas	Adecuado para colecciones grandes o operaciones que pueden detenerse temprano (take, find, first, any, all, none)

El uso de funciones estándar en colecciones suele ser suficiente y más conciso. Sequences se recomiendan cuando se necesita una pereza explícita para optimizar el rendimiento al trabajar con grandes volúmenes de datos.