Prelevare e filtrare in modo lazy
Suddivida stream infiniti.
Prelevare e filtrare in modo lazy è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 4 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 Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Consumo lazy
Il vero valore di una LazyList emerge quando la si consuma. Operazioni come take, filter e map rimangono lazy e calcolano solo le celle che alla fine si forzano.
Questa lezione illustra i principali trasformatori e come interrompere la valutazione lazy al momento giusto.
take(n)
take(n) restituisce una LazyList contenente al massimo i primi n elementi, anch'essa lazy. Non viene calcolato nulla finché non si forza il risultato.
È il modo sicuro per porre un limite a uno stream infinito.
object Demo extends App {
val first5 = LazyList.from(1).take(5)
println(first5.toList)
}takeWhile
takeWhile(p) restituisce gli elementi finché il predicato è soddisfatto, poi si ferma al primo elemento che non lo soddisfa.
Su uno stream infinito, offre una condizione di arresto chiara senza dover conoscere una quantità di elementi.
object Demo extends App {
val small = LazyList.from(1).takeWhile(_ < 6)
println(small.toList)
}drop e dropWhile
drop(n) salta i primi n elementi; dropWhile(p) salta gli elementi finché il predicato è soddisfatto. Entrambi restituiscono la parte rimanente in modo lazy.
Li utilizzi per spostarsi all'interno di uno stream prima di prendere una porzione.
object Demo extends App {
val rest = LazyList.from(1).drop(3).take(3)
println(rest.toList)
}Filtro lazy
filter su una LazyList è lazy: verifica gli elementi solo quando il consumatore a valle li richiede.
Combinato con take, elabora esattamente il numero di elementi sorgente necessario a soddisfare la richiesta, non di più.
object Demo extends App {
val evens = LazyList.from(1).filter(_ % 2 == 0)
println(evens.take(4).toList)
}Osservare la richiesta
Aggiunga una stampa all'interno del predicato per osservare quanti pochi elementi vengono verificati. Il filtro viene eseguito solo finché take non è soddisfatto.
Esegua questo codice: il numero di righe "check" mostra una valutazione guidata dalla richiesta, non l'elaborazione dell'intero stream.
object Demo extends App {
val r = LazyList.from(1).filter { n =>
println("check " + n); n % 3 == 0
}
println(r.take(2).toList)
}Concatenare map e filter
È possibile concatenare i trasformatori: l'intera pipeline rimane lazy e viene fusa elemento per elemento. Ogni elemento sorgente passa prima attraverso map e poi attraverso filter solo quando viene richiesto.
Non vengono create raccolte intermedie complete.
object Demo extends App {
val r = LazyList.from(1).map(_ * _).filter(_ > 10).take(3)
println(r.toList)
}find: arresto anticipato
find(p) restituisce il primo elemento che corrisponde al predicato come Option, forzando la valutazione solo fino a quell'elemento. È perfetto per cercare in uno stream infinito.
Quando trova una corrispondenza, la valutazione si arresta immediatamente.
object Demo extends App {
val firstBig = LazyList.from(1).find(_ * _ > 50)
println(firstBig)
}headOption ed exists
headOption consente di esaminare in sicurezza il primo elemento; exists(p) forza la valutazione solo fino a trovare una corrispondenza, oppure per sempre se non ne trova alcuna. Utilizzi exists su stream infiniti solo quando è garantita una corrispondenza.
Entrambi si arrestano il prima possibile.
object Demo extends App {
val has = LazyList.from(1).exists(_ == 7)
println(has)
}Forzare un risultato
I trasformatori lazy descrivono il lavoro da eseguire; un'operazione terminale lo forza. toList, foreach, sum e foldLeft consumano lo stream (limitato) e producono un valore concreto.
Ponga sempre un limite a uno stream infinito prima di un'operazione terminale che richiede tutti i suoi elementi.
object Demo extends App {
val total = LazyList.from(1).take(100).sum
println(total)
}Problemi durante il filtraggio
Un filter che non trova corrispondenze trasforma un take limitato in una ricerca infinita. LazyList.from(1).filter(_ < 0).take(1) rimane bloccato per sempre.
Si assicuri che i predicati possano essere soddisfatti, oppure abbini il filtro a takeWhile per garantire la terminazione.
Verifica rapida
Verifichi la propria comprensione del consumo lazy.
Riepilogo
take, takeWhile, drop, filter e map rimangono lazy e vengono fusi elemento per elemento; find, exists e headOption si arrestano anticipatamente; le operazioni terminali come toList e sum forzano il risultato.
Presti attenzione ai filtri non soddisfacibili sugli stream infiniti. Ora è in grado di generare e consumare sequenze lazy con sicurezza.
Impara Scala con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 39
- Lezioni
- 143
Domande Frequenti
La lezione «Prelevare e filtrare in modo lazy» è gratuita?
Sì — il testo completo di «Prelevare e filtrare in modo 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 Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Cosa imparerò in «Prelevare e filtrare in modo lazy»?
Suddivida stream infiniti. Eserciti Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Prelevare e filtrare in modo 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 Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming 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.
Tutte le lezioni di questo corso
- La pigrizia spiegata
- Costruire una LazyList
- Stream infiniti
- Prelevare e filtrare in modo lazy