Operacje leniwe
Unikaj list pośrednich
Operacje leniwe to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.
Operacje leniwe
Siła sekwencji wynika z leniwego wykonywania operacji. Operacje pośrednie tworzą potok przetwarzania, ale go nie uruchamiają — dopiero operacja końcowa pobiera z niego elementy. Dzięki temu nie powstają listy pośrednie.
Brak list pośrednich
W przypadku kolekcji każde map i filter przydziela pamięć na nową listę. W przypadku sekwencji elementy przepływają przez wszystkie kroki bez tworzenia tych tymczasowych list.
fun main() {
val result = (1..6).asSequence()
.map { it * it }
.filter { it % 2 == 0 }
.toList()
println(result)
}Obserwowanie leniwości
Bez operacji końcowej żadna z lambd nie zostanie uruchomiona. Potok jest tylko receptą, dopóki nie zostanie skonsumowany.
fun main() {
val pipeline = (1..3).asSequence()
.map { println("map $it"); it }
println("Built pipeline, nothing ran")
pipeline.toList()
}take ogranicza pracę
take(n) jest leniwą operacją pośrednią. W połączeniu z generatorem nieskończonym zatrzymuje się po wygenerowaniu n elementów.
fun main() {
val firstThree = generateSequence(1) { it + 1 }
.map { it * 10 }
.take(3)
.toList()
println(firstThree)
}first przerywa przetwarzanie
Operacje końcowe, takie jak first, zatrzymują się, gdy tylko uzyskają potrzebny wynik, całkowicie pomijając pozostałe elementy.
fun main() {
val result = (1..1000).asSequence()
.map { println("processing $it"); it }
.first { it > 3 }
println("Found $result")
}Przetwarzanie strumieniowe element po elemencie
W sekwencji element 1 przechodzi przez map, a następnie przez filter, potem element 2 i tak dalej. Taka kolejność umożliwia wcześniejsze zakończenie przetwarzania i eliminuje konieczność buforowania wszystkich wyników.
fun main() {
listOf(1, 2, 3, 4).asSequence()
.filter { println("filter $it"); it % 2 == 0 }
.map { println("map $it"); it * 10 }
.toList()
}takeWhile i dropWhile
takeWhile zwraca elementy, dopóki predykat nie zwróci wartości false, a dropWhile pomija początkowe elementy, dopóki predykat zwraca wartość true. Obie operacje są leniwe.
fun main() {
val nums = generateSequence(1) { it + 1 }
println(nums.takeWhile { it < 5 }.toList())
}Unikanie zbędnych obliczeń
Ponieważ nic nie jest wykonywane przed skonsumowaniem sekwencji, a przetwarzanie może zakończyć się wcześniej, kosztowne przekształcenia są stosowane tylko do elementów, które rzeczywiście docierają do operacji końcowej.
fun main() {
val result = (1..100).asSequence()
.map { it * 2 }
.filter { it > 10 }
.take(2)
.toList()
println(result)
}Ponowne używanie sekwencji
Większość sekwencji można iterować wielokrotnie, za każdym razem ponownie uruchamiając potok. Jednak sekwencje pochodzące ze źródeł jednorazowych, takich jak iterator, można skonsumować tylko raz. Należy zwracać uwagę na źródło.
fun main() {
val seq = sequenceOf(1, 2, 3).map { it * 2 }
println(seq.toList())
println(seq.sum())
}Operacje stanowe i bezstanowe
Większość operacji jest bezstanowa — przetwarza jeden element naraz. Niektóre, takie jak sorted lub distinct, są stanowe i muszą buforować albo przejrzeć wszystkie elementy, co zmniejsza korzyści z leniwego wykonywania.
fun main() {
val result = sequenceOf(3, 1, 2, 1).distinct().sorted().toList()
println(result)
}Korzyści z leniwości
Leniwe operacje oszczędzają pamięć, pomijając listy pośrednie, oraz czas, kończąc przetwarzanie wcześniej. Im większe są dane i im bardziej selektywna jest operacja końcowa, tym większa jest korzyść.
Szybkie sprawdzenie
Kiedy lambdy w łańcuchu sekwencji są faktycznie wykonywane?
Podsumowanie
Leniwe operacje tworzą potok, który uruchamia się dopiero wtedy, gdy operacja końcowa go skonsumuje. Dzięki temu nie powstają listy pośrednie, a operacje takie jak first, take i takeWhile mogą wcześniej zakończyć przetwarzanie. Należy uważać na operacje stanowe, takie jak sorted. Następnie zostanie omówione, kiedy sekwencje są lepszym wyborem niż kolekcje.
Ucz się Kotlin dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 51
- Lekcje
- 203
Często zadawane pytania
Czy lekcja „Operacje leniwe” jest bezpłatna?
Tak — pełny tekst „Operacje leniwe” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Operacje leniwe”?
Unikaj list pośrednich Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?
Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Operacje leniwe”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?
Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Dlaczego sekwencje
- Tworzenie sekwencji
- Operacje leniwe
- Sekwencje a kolekcje