Kotlin Academy · Lektion

Kedja pipelines och undvik mellanliggande listor med Sequence

Bygg pipelines i flera steg och använd Sequence för lat utvärdering.

Lektion 4 av 413 steg

Kedja pipelines och undvik mellanliggande listor med Sequence är en gratis lektion i Kotlin Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Kotlin Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Problemet: mellanliggande listor

Varje samlingsoperation (filter, map och så vidare) skapar en ny lista. För stora samlingar eller långa kedjor slösar detta minne och tid.

Girig kontra lat utvärdering

Samlingsoperationer är giriga: varje steg bearbetar hela listan innan nästa steg börjar. Sequence-operationer är lata: ett element bearbetas genom alla steg innan nästa element behandlas.

Konvertera till Sequence

Anropa asSequence() för att växla från girig listbearbetning till lat sekvensbearbetning.
val result = (1..1_000_000)
    .asSequence()
    .filter { it % 2 == 0 }
    .map { it * it }
    .take(5)
    .toList()
println(result)  // [4, 16, 36, 64, 100]

Sequence är lat: inget arbete före terminaloperationen

Ingen beräkning sker förrän Ni anropar en terminaloperator (toList, first, sum och så vidare).
val seq = generateSequence(1) { it + 1 }  // infinite!
    .filter { it % 3 == 0 }
    .map { it * it }
val first5 = seq.take(5).toList()
println(first5)  // [9, 36, 81, 144, 225]

generateSequence: oändliga sekvenser

generateSequence skapar lata, oändliga sekvenser.
val fibonacci = generateSequence(Pair(0, 1)) { (a, b) -> Pair(b, a + b) }
    .map { it.first }
val first10 = fibonacci.take(10).toList()
println(first10)  // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

sequence Builder

Byggaren sequence { } med yield skapar anpassade lata sekvenser.
val evens = sequence {
    var n = 0
    while (true) {
        yield(n)
        n += 2
    }
}
println(evens.take(5).toList())  // [0, 2, 4, 6, 8]

När Sequence ska användas

Använd Sequence när samlingen är stor (>1000 element), när Ni använder flera kedjade operationer och/eller när Ni bara behöver en liten delmängd av resultaten.

När Sequence INTE ska användas

För små samlingar (<100 element) medför sekvenser extra overhead. Den iteratorbaserade mekanismen är långsammare för korta kedjor.
// Overkill for small list:
listOf(1, 2, 3).asSequence().map { it * 2 }.toList()
// Just use:
listOf(1, 2, 3).map { it * 2 }

Terminaloperationer för Sequence

Terminaloperationer utlöser bearbetningen. Vanliga sådana är: toList(), first(), last(), count(), sum(), any(), all() och none().
val s = (1..100).asSequence().filter { it % 7 == 0 }
println(s.first())          // 7
println(s.count())          // 14
println(s.sum())            // 728

Tillståndsbaserade och tillståndslösa operationer

Vissa sequence-operationer är tillståndsbaserade (sort, distinct) – de måste se alla element innan de kan producera utdata. De bryter den lata utvärderingen.
val s = (1..10).asSequence()
    .filter { it > 3 }   // stateless: lazy
    .sorted()            // stateful: must see all elements
    .take(3).toList()
println(s)  // [4, 5, 6]

constrainOnce: säkerhet vid en enda iteration

Använd constrainOnce() för att få en sekvens att kasta ett undantag om den itereras flera gånger – användbart för strömmar.
val seq = generateSequence(1) { if (it < 5) it + 1 else null }
    .constrainOnce()
val first = seq.toList()   // OK
// val second = seq.toList()  // IllegalStateException!

Snabb kontroll

När börjar en Sequence bearbeta element?

Sammanfattning

Sekvenser är lata – inget arbete utförs före en terminaloperation. Använd asSequence() för stora samlingar med flera kedjade operationer. generateSequence och sequence { } skapar oändliga lata strömmar. Terminaloperationer utlöser bearbetningen.
Gratis att börja

Lär dig Kotlin med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
51
Lektioner
203

Vanliga frågor

Är lektionen ”Kedja pipelines och undvik mellanliggande listor med Sequence” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Kotlin Academy, inklusive ”Kedja pipelines och undvik mellanliggande listor med Sequence”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Kotlin Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Kedja pipelines och undvik mellanliggande listor med Sequence”?

Bygg pipelines i flera steg och använd Sequence för lat utvärdering. Ni övar på Kotlin Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Kotlin Academy?

Du behöver inga förkunskaper. Utbildningen i Kotlin Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Kedja pipelines och undvik mellanliggande listor med Sequence”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Kotlin Academy-lektionen?

Ja. Varje Kotlin Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. map och flatMap: omforma varje element
  2. filter, filterNot och partition
  3. fold, reduce och runningFold
  4. Kedja pipelines och undvik mellanliggande listor med Sequence
← Tillbaka till Kotlin Academy