Hoe werk je met streams in Kotlin?

In Kotlin worden voor het werken met datastromen (vergelijkbaar met Java 8 Streams API) extensiefuncties voor collecties gebruikt, geleverd door de standaard functiebibliotheek. Dit is geen aparte API, maar een verzameling methoden in kotlin.collections.

De belangrijkste operaties op stromen worden onderverdeeld in:

• Intermediaire operaties: Ze geven een nieuwe collectie terug en zijn "lui" (worden alleen uitgevoerd bij het aanroepen van een terminale operatie). Voorbeelden: filter, map, flatMap, distinct, sorted, take, drop.
• Terminale operaties: Voltooien de opeenvolging van operaties en geven een resultaat terug (geen collectie). Ze activeren de uitvoering van alle intermediaire operaties. Voorbeelden: forEach, reduce, fold, count, sum, average, min, max, toList, toSet, toMap.

Er bestaat ook het concept van sequenties (sequences), die expliciete luiheid bieden. Sequenties verwerken elementen één voor één indien nodig, wat efficiënter kan zijn voor grote collecties of lange ketens van operaties:

• Aanmaken van een sequentie: collection.asSequence()
• Terug converteren naar collectie: sequence.toList()

// Voorbeeld van gebruik van standaardfuncties voor stroomverwerking
fun processCollection() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val evenSquares = numbers
        .filter { it % 2 == 0 } // Intermediaire operatie: filter even getallen
        .map { it * it }     // Intermediaire operatie: kwadrateren

    println(evenSquares) // Terminal operatie: toont de collectie (voert filter en map uit)

    val sumOfOdd = numbers
        .filter { it % 2 != 0 } // Intermediair
        .sum()                // Terminal (berekent som van oneven)

    println(sumOfOdd)
}

// Voorbeeld van gebruik van sequenties
fun processSequence() {
    val largeCollection = (1..1_000_000).toList()

    // Met collecties (niet lui): filter en map worden onmiddellijk voor alle elementen uitgevoerd
    val resultCollection = largeCollection
        .filter { it % 2 == 0 }
        .map { it * 2 }
        .take(10) // take(10) wordt uitgevoerd na filter en map voor alle

    println("Resultaat collectie grootte: ${resultCollection.size}")

    // Met sequenties (lui): filter, map en take worden element voor element uitgevoerd
    val resultSequence = largeCollection.asSequence()
        .filter { it % 2 == 0 } // filter wordt voor elk element in volgorde uitgevoerd
        .map { it * 2 }     // map wordt voor elk door filter gegaan element uitgevoerd
        .take(10)         // take(10) stopt de verwerking na 10 elementen

    println("Resultaat sequentie grootte: ${resultSequence.toList().size}") // toList() activeert de uitvoering van de sequentie
}

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

Vergelijkingstabel van standaardfuncties en sequenties met betrekking tot luiheid:

Eigenschap	Standaardcollectiefuncties	Sequenties
Luiheid	Impliciete luiheid voor tussenoperaties, maar de terminale operatie verwerkt de hele tussenketen	Expliciete luiheid: operaties worden element voor element uitgevoerd indien nodig
Efficiëntie	Kan minder efficiënt zijn voor grote collecties en lange ketens van operaties vanwege tussencollecties	Efficiënter voor grote collecties en lange ketens van operaties
Toepassing	Geschikt voor kleine en middelgrote collecties	Geschikt voor grote collecties of operaties die vroeg kunnen worden afgebroken (take, find, first, any, all, none)

Het gebruik van standaardfuncties op collecties is meestal voldoende en beknopter. Sequenties worden aanbevolen wanneer expliciete luiheid nodig is om de prestaties te optimaliseren bij het werken met grote hoeveelheden data.