Operazioni lazy
Eviti le liste intermedie
Operazioni lazy è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.
Operazioni lazy
La potenza delle sequenze deriva dalle operazioni lazy. Le operazioni intermedie costruiscono una pipeline senza eseguirla, e solo un'operazione terminale fa avanzare gli elementi. In questo modo si evitano le liste intermedie.
Nessuna lista intermedia
Con le collezioni, ogni map e filter alloca una nuova lista. Con le sequenze, gli elementi attraversano tutti i passaggi senza creare queste liste temporanee.
fun main() {
val result = (1..6).asSequence()
.map { it * it }
.filter { it % 2 == 0 }
.toList()
println(result)
}Osservare la valutazione lazy
Senza un'operazione terminale, nessuna lambda viene eseguita. La pipeline è solo una ricetta finché non viene consumata.
fun main() {
val pipeline = (1..3).asSequence()
.map { println("map $it"); it }
println("Built pipeline, nothing ran")
pipeline.toList()
}take limita il lavoro
take(n) è un'operazione intermedia lazy. In combinazione con un generatore infinito, si interrompe dopo aver prodotto n elementi.
fun main() {
val firstThree = generateSequence(1) { it + 1 }
.map { it * 10 }
.take(3)
.toList()
println(firstThree)
}first interrompe l'elaborazione
Le operazioni terminali come first si interrompono non appena hanno ciò che serve, saltando completamente gli elementi rimanenti.
fun main() {
val result = (1..1000).asSequence()
.map { println("processing $it"); it }
.first { it > 3 }
println("Found $result")
}Elaborazione elemento per elemento
In una sequenza, l'elemento 1 attraversa prima map e poi filter, quindi tocca all'elemento 2, e così via. È questo ordine a rendere possibile l'interruzione anticipata e a evitare di memorizzare tutti i risultati.
fun main() {
listOf(1, 2, 3, 4).asSequence()
.filter { println("filter $it"); it % 2 == 0 }
.map { println("map $it"); it * 10 }
.toList()
}takeWhile e dropWhile
takeWhile restituisce gli elementi finché il predicato non restituisce false; dropWhile salta gli elementi iniziali finché il predicato restituisce true. Entrambe sono lazy.
fun main() {
val nums = generateSequence(1) { it + 1 }
println(nums.takeWhile { it < 5 }.toList())
}Evitare calcoli inutili
Poiché nulla viene eseguito prima del consumo e il consumo può interrompersi in anticipo, le trasformazioni costose vengono applicate solo agli elementi che raggiungono effettivamente un'operazione terminale.
fun main() {
val result = (1..100).asSequence()
.map { it * 2 }
.filter { it > 10 }
.take(2)
.toList()
println(result)
}Riutilizzare le sequenze
La maggior parte delle sequenze può essere iterata più volte, rieseguendo la pipeline ogni volta. Tuttavia, le sequenze create da sorgenti utilizzabili una sola volta, come un iteratore, possono essere consumate una sola volta. Presti attenzione alla sorgente.
fun main() {
val seq = sequenceOf(1, 2, 3).map { it * 2 }
println(seq.toList())
println(seq.sum())
}Operazioni con e senza stato
La maggior parte delle operazioni è senza stato ed elabora un elemento alla volta. Alcune, come sorted o distinct, mantengono uno stato e devono memorizzare o analizzare tutti gli elementi, riducendo il vantaggio della valutazione lazy.
fun main() {
val result = sequenceOf(3, 1, 2, 1).distinct().sorted().toList()
println(result)
}I vantaggi della valutazione lazy
Le operazioni lazy fanno risparmiare memoria evitando le liste intermedie e fanno risparmiare tempo interrompendo l'elaborazione appena possibile. Più grandi sono i dati e più selettiva è l'operazione terminale, maggiore sarà il vantaggio.
Verifica rapida
Quando vengono eseguite effettivamente le lambda in una catena di sequenze?
Riepilogo
Le operazioni lazy costruiscono una pipeline che viene eseguita solo quando un'operazione terminale la consuma, evitando le liste intermedie e consentendo l'interruzione anticipata con first, take e takeWhile. Presti attenzione alle operazioni con stato come sorted. Nel prossimo capitolo deciderà quando le sequenze sono preferibili alle collezioni.
Domande Frequenti
La lezione «Operazioni lazy» è gratuita?
Sì — il testo completo di «Operazioni lazy» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.
Cosa imparerò in «Operazioni lazy»?
Eviti le liste intermedie Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Kotlin Academy?
Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Operazioni lazy»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?
Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.