Lazy-operationer
Undgå mellemliggende lister
Lazy-operationer er en gratis Kotlin Academy-lektion på CoddyKit. Dette er lektion 3 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.
Dovne operationer
Styrken ved sekvenser skyldes dovne operationer. Mellemliggende operationer opbygger en behandlingskæde uden at køre den, og først en afsluttende operation trækker elementerne gennem den. Det undgår mellemliggende lister.
Ingen mellemliggende lister
Med samlinger allokerer hver map og filter en ny liste. Med sekvenser flyder elementerne gennem alle trin uden at oprette disse midlertidige lister.
fun main() {
val result = (1..6).asSequence()
.map { it * it }
.filter { it % 2 == 0 }
.toList()
println(result)
}Sådan observerer du doven evaluering
Uden en afsluttende operation køres ingen af lambdaerne. Behandlingskæden er blot en opskrift, indtil den forbruges.
fun main() {
val pipeline = (1..3).asSequence()
.map { println("map $it"); it }
println("Built pipeline, nothing ran")
pipeline.toList()
}take begrænser arbejdet
take(n) er en doven mellemliggende operation. Kombineret med en uendelig generator stopper den, efter at den har produceret n elementer.
fun main() {
val firstThree = generateSequence(1) { it + 1 }
.map { it * 10 }
.take(3)
.toList()
println(firstThree)
}first afbryder tidligt
Afsluttende operationer som first stopper, så snart de har det, de skal bruge, og springer helt over resten af elementerne.
fun main() {
val result = (1..1000).asSequence()
.map { println("processing $it"); it }
.first { it > 3 }
println("Found $result")
}Behandling element for element
I en sekvens går element 1 gennem map og derefter filter, så element 2 og så videre. Det er denne rækkefølge, der muliggør tidlig afbrydelse og undgår at gemme alle resultater i en buffer.
fun main() {
listOf(1, 2, 3, 4).asSequence()
.filter { println("filter $it"); it % 2 == 0 }
.map { println("map $it"); it * 10 }
.toList()
}takeWhile og dropWhile
takeWhile leverer elementer, indtil prædikatet fejler; dropWhile springer indledende elementer over, så længe prædikatet gælder. Begge er dovne.
fun main() {
val nums = generateSequence(1) { it + 1 }
println(nums.takeWhile { it < 5 }.toList())
}Undgå spildte beregninger
Fordi intet kører, før det forbruges, og forbruget kan stoppe tidligt, anvendes dyre transformationer kun på de elementer, der faktisk når frem til en afsluttende operation.
fun main() {
val result = (1..100).asSequence()
.map { it * 2 }
.filter { it > 10 }
.take(2)
.toList()
println(result)
}Genbrug af sekvenser
De fleste sekvenser kan gennemløbes flere gange, så behandlingskæden køres igen hver gang. Sekvenser fra kilder, der kun kan bruges én gang, som f.eks. en iterator, kan dog kun forbruges én gang. Vær opmærksom på kilden.
fun main() {
val seq = sequenceOf(1, 2, 3).map { it * 2 }
println(seq.toList())
println(seq.sum())
}Tilstandsfulde og tilstandsløse operationer
De fleste operationer er tilstandsløse og behandler ét element ad gangen. Nogle, f.eks. sorted eller distinct, er tilstandsfulde og skal gemme eller gennemgå alle elementer, hvilket mindsker fordelen ved doven evaluering.
fun main() {
val result = sequenceOf(3, 1, 2, 1).distinct().sorted().toList()
println(result)
}Gevinsten ved doven evaluering
Dovne operationer sparer hukommelse ved at springe mellemliggende lister over og sparer tid ved at afbryde tidligt. Jo større data mængden er, og jo mere selektiv den afsluttende operation er, desto større er gevinsten.
Hurtig kontrol
Hvornår bliver lambdaerne i en sekvenskæde faktisk kørt?
Opsummering
Dovne operationer opbygger en behandlingskæde, der kun kører, når en afsluttende operation forbruger den. Det undgår mellemliggende lister og muliggør tidlig afbrydelse med first, take og takeWhile. Vær opmærksom på tilstandsfulde operationer som sorted. Nu skal du afgøre, hvornår sekvenser er bedre end samlinger.
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 “Lazy-operationer” gratis?
Ja — alle 3 lektioner i læringssporet Kotlin Academy, inklusive “Lazy-operationer”, 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 “Lazy-operationer”?
Undgå mellemliggende lister 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 3 af 4.
Hvor lang tid tager lektionen “Lazy-operationer”?
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.