Come lavorare con i flussi (streams) in Kotlin…

In Kotlin, per lavorare con flussi di dati (equivalente a Java 8 Streams API), si utilizzano funzioni di estensione per le collezioni fornite dalla libreria di funzioni standard. Non è un'API separata, ma un insieme di metodi in kotlin.collections.

Le operazioni principali sui flussi sono:

Operazioni intermedie: Restituiscono una nuova collezione e sono "pigre" (si eseguono solo chiamando un'operazione terminale). Esempi: filter, map, flatMap, distinct, sorted, take, drop.
Operazioni terminali: Concludono la sequenza di operazioni e restituiscono un risultato (non una collezione). Attivano l'esecuzione di tutte le operazioni intermedie. Esempi: forEach, reduce, fold, count, sum, average, min, max, toList, toSet, toMap.

Esiste anche il concetto di sequenze (sequences), che fornisce una pigrizia esplicita. Le sequenze elaborano gli elementi uno ad uno secondo necessità, il che può essere più efficiente per grandi collezioni o lunghe catene di operazioni:

Creazione di una sequenza: collection.asSequence()
Conversione di nuovo in collezione: sequence.toList()

// Esempio di utilizzo di funzioni standard per l'elaborazione in flusso
fun processCollection() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val evenSquares = numbers
        .filter { it % 2 == 0 } // Operazione intermedia: filtra i numeri pari
        .map { it * it }     // Operazione intermedia: eleva al quadrato

    println(evenSquares) // Operazione terminale: mostra la collezione (esegue filter e map)

    val sumOfOdd = numbers
        .filter { it % 2 != 0 } // Intermedia
        .sum()                // Terminal (calcola la somma dei dispari)

    println(sumOfOdd)
}

// Esempio di utilizzo di sequenze
fun processSequence() {
    val largeCollection = (1..1_000_000).toList()

    // Con collezioni (non pigre): filter e map si eseguono subito per tutti gli elementi
    val resultCollection = largeCollection
        .filter { it % 2 == 0 }
        .map { it * 2 }
        .take(10) // take(10) si esegue dopo filter e map per tutti

    println("Dimensione risultato collezione: ${resultCollection.size}")

    // Con sequenze (pigre): filter, map e take si eseguono elemento per elemento
    val resultSequence = largeCollection.asSequence()
        .filter { it % 2 == 0 } // filter si esegue per ogni elemento in ordine
        .map { it * 2 }     // map si esegue per ogni elemento che supera il filtro
        .take(10)         // take(10) ferma l'elaborazione dopo 10 elementi

    println("Dimensione risultato sequenza: ${resultSequence.toList().size}") // toList() attiva l'esecuzione della sequenza
}

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

Tabella comparativa di funzioni standard e sequenze riguardo alla pigrizia:

Caratteristica	Funzioni standard delle collezioni	Sequenze
Pigrizia	Pigrizia implicita per le operazioni intermedie, ma l'operazione terminale processa tutta la catena intermedia	Pigrizia esplicita: le operazioni vengono eseguite elemento per elemento secondo necessità
Efficienza	Può essere meno efficiente per grandi collezioni e lunghe catene di operazioni a causa delle collezioni intermedie	Più efficiente per grandi collezioni e lunghe catene di operazioni
Applicazione	Adatto per collezioni piccole e medie	Adatto per grandi collezioni o operazioni che possono essere interrotte presto (`take`, `find`, `first`, `any`, `all`, `none`)

L'uso delle funzioni standard sulle collezioni è generalmente sufficiente e più conciso. Le sequenze sono raccomandate quando è necessaria una pigrizia esplicita per ottimizzare le prestazioni con grandi volumi di dati.

Come lavorare con i flussi (streams) in Kotlin?