Kotlin Academy · Lektion

Kædning af pipelines og undgåelse af mellemliggende lister med Sequence

Byg pipelines i flere trin, og brug Sequence til lazy evaluering.

Lektion 4 af 413 trin

Kædning af pipelines og undgåelse af mellemliggende lister med Sequence er en gratis Kotlin Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Kotlin Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Kotlin Academy-kurset indeholder 4 lektioner i alt.

Problemet: mellemliggende lister

Hver samlingsoperation (filter, map osv.) opretter en ny liste. For store samlinger eller lange kæder spilder det hukommelse og tid.

Ivrig og doven evaluering

Samlingsoperationer er ivrige: hvert trin behandler hele listen, før det næste trin begynder. Sequence-operationer er dovne: ét element behandles gennem alle trin, før det næste element behandles.

Konvertering til Sequence

Kald asSequence() for at skifte fra ivrig behandling af lister til doven behandling af sekvenser.
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 er doven: intet arbejde før en afsluttende operation

Ingen beregning finder sted, før du kalder en afsluttende operator (toList, first, sum osv.).
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: uendelige sekvenser

generateSequence opretter dovne, uendelige 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

Byggefunktionen sequence { } med yield opretter brugerdefinerede, dovne sekvenser.
val evens = sequence {
    var n = 0
    while (true) {
        yield(n)
        n += 2
    }
}
println(evens.take(5).toList())  // [0, 2, 4, 6, 8]

Hvornår skal du bruge Sequence

Brug Sequence når: samlingen er stor (>1000 elementer), du bruger flere kædede operationer, og/eller du kun har brug for en lille delmængde af resultaterne.

Hvornår skal du IKKE bruge Sequence

Ved små samlinger (<100 elementer) tilfører sekvenser ekstra omkostninger. Den iteratorbaserede mekanisme er langsommere ved korte kæder.
// Overkill for small list:
listOf(1, 2, 3).asSequence().map { it * 2 }.toList()
// Just use:
listOf(1, 2, 3).map { it * 2 }

Afsluttende Sequence-operationer

Afsluttende operationer udløser behandlingen. Almindelige operationer er: toList(), first(), last(), count(), sum(), any(), all() og none().
val s = (1..100).asSequence().filter { it % 7 == 0 }
println(s.first())          // 7
println(s.count())          // 14
println(s.sum())            // 728

Tilstandsafhængige og tilstandsløse operationer

Nogle sekvensoperationer er tilstandsafhængige (sort, distinct) – de skal se alle elementer, før de kan producere output. De bryder den dovne evaluering.
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: sikkerhed ved én gennemløbning

Brug constrainOnce() til at få en sekvens til at kaste en fejl, hvis den gennemløbes flere gange – nyttigt til datastrømme.
val seq = generateSequence(1) { if (it < 5) it + 1 else null }
    .constrainOnce()
val first = seq.toList()   // OK
// val second = seq.toList()  // IllegalStateException!

Hurtigt tjek

Hvornår begynder en Sequence at behandle elementer?

Opsummering

Sekvenser er dovne – der udføres ikke arbejde før en afsluttende operation. Brug asSequence() til store samlinger med flere kædede operationer. generateSequence og sequence { } opretter uendelige, dovne datastrømme. Afsluttende operationer udløser behandlingen.
Gratis at komme i gang

Lær Kotlin med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
51
Lektioner
203

Ofte stillede spørgsmål

Er lektionen “Kædning af pipelines og undgåelse af mellemliggende lister med Sequence” gratis?

Ja — alle 3 lektioner i læringssporet Kotlin Academy, inklusive “Kædning af pipelines og undgåelse af mellemliggende lister med Sequence”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Kotlin Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Kædning af pipelines og undgåelse af mellemliggende lister med Sequence”?

Byg pipelines i flere trin, og brug Sequence til lazy evaluering. Du øver dig i Kotlin Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Kotlin Academy?

Der kræves ingen tidligere erfaring. Kotlin Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Kædning af pipelines og undgåelse af mellemliggende lister med Sequence”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Kotlin Academy-lektion?

Ja. Alle Kotlin Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. map og flatMap: Transformation af hvert element
  2. filter, filterNot og partition
  3. fold, reduce og runningFold
  4. Kædning af pipelines og undgåelse af mellemliggende lister med Sequence
← Tilbage til Kotlin Academy