PricingLoginStart free
Kotlin Academy · leksjon

Kjede pipelines og unngå mellomliggende lister med Sequence

Bygg pipelines med flere trinn, og bruk Sequence for lat evaluering.

Leksjon 4 av 413 trinn

Kjede pipelines og unngå mellomliggende lister med Sequence er en gratis leksjon i Kotlin Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Kotlin Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Problemet: mellomlister

Hver samlingsoperasjon (filter, map og så videre) oppretter en ny liste. For store samlinger eller lange kjeder sløser dette med minne og tid.

Eager kontra lazy-evaluering

Samlingsoperasjoner er eager: hvert trinn behandler hele listen før det neste starter. Sequence-operasjoner er lazy: ett element behandles gjennom alle trinn før neste element behandles.

Konvertering til Sequence

Kall asSequence() for å bytte fra eager (listebasert) til lazy (sekvensbasert) behandling.
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 lazy: ingen behandling før en terminaloperasjon

Ingen beregning skjer før du kaller en terminaloperator (toList, first, sum og så videre).
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 oppretter late, 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-bygging

sequence { }-byggeren med yield oppretter tilpassede, late 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 bør Sequence brukes

Bruk Sequence når samlingen er stor (>1000 elementer), når du bruker flere operasjoner i kjede, og/eller når du bare trenger et lite delsett av resultatene.

Når Sequence IKKE bør brukes

For små samlinger (<100 elementer) medfører sekvenser ekstra kostnader. Den iteratorbaserte mekanismen er langsommere for korte kjeder.
// Overkill for small list:
listOf(1, 2, 3).asSequence().map { it * 2 }.toList()
// Just use:
listOf(1, 2, 3).map { it * 2 }

Terminaloperasjoner for Sequence

Terminaloperasjoner starter behandlingen. Vanlige operasjoner er: toList(), first(), last(), count(), sum(), any(), all(), none().
val s = (1..100).asSequence().filter { it % 7 == 0 }
println(s.first())          // 7
println(s.count())          // 14
println(s.sum())            // 728

Tilstandsfulle kontra tilstandsløse operasjoner

Noen sekvensoperasjoner er stateful (sort, distinct) – de må se alle elementene før de kan produsere et resultat. De bryter med lat 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: sikkerhet for én gjennomgang

Bruk constrainOnce() for å få en sekvens til å kaste en feil hvis den itereres flere ganger – nyttig for strømmer.
val seq = generateSequence(1) { if (it < 5) it + 1 else null }
    .constrainOnce()
val first = seq.toList()   // OK
// val second = seq.toList()  // IllegalStateException!

Hurtigsjekk

Når begynner en Sequence å behandle elementer?
Besvar den i den interaktive leksjonen

Oppsummering

Sekvenser er late – ingen behandling skjer før en terminaloperator. Bruk asSequence() for store samlinger med flere operasjoner i kjede. generateSequence og sequence { } oppretter uendelige, late strømmer. Terminaloperasjoner starter behandlingen.
Gratis å komme i gang

Lær deg Kotlin med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
51
Leksjoner
203
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Kjede pipelines og unngå mellomliggende lister med Sequence» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Kotlin Academy, inkludert «Kjede pipelines og unngå mellomliggende lister med Sequence», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Kjede pipelines og unngå mellomliggende lister med Sequence»?

Bygg pipelines med flere trinn, og bruk Sequence for lat evaluering. Du øver på Kotlin Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Kotlin Academy?

Ingen tidligere erfaring er nødvendig. Kotlin Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Kjede pipelines og unngå mellomliggende lister med Sequence»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Kotlin Academy-leksjonen?

Ja. Alle Kotlin Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. map og flatMap: Transformere hvert element
  2. filter, filterNot og partition
  3. fold, reduce og runningFold
  4. Kjede pipelines og unngå mellomliggende lister med Sequence
← Tilbake til Kotlin Academy