Kotlin Academy · Lekcja

Dlaczego sekwencje

Leniwa ewaluacja

Dlaczego sekwencje to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 1 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.

Czym są sekwencje?

Sequence przypomina kolekcję, ale przetwarza elementy leniwe. Operacje nie są wykonywane, dopóki operacja terminalna nie zażąda wyników, a elementy przechodzą przez cały łańcuch pojedynczo.

Kolekcje przetwarzane zachłannie

Standardowe operacje na kolekcjach są wykonywane zachłannie: każdy krok (filter, map) w całości przetwarza listę i tworzy nową listę pośrednią, zanim rozpocznie się kolejny krok.

fun main() {
    val result = listOf(1, 2, 3, 4)
        .map { it * 2 }
        .filter { it > 4 }
    println(result)
}

Koszt list pośrednich

W przypadku dużych zbiorów danych przetwarzanie zachłanne przydziela nową listę na każdym kroku. Przy wielu operacjach lub milionach elementów powoduje to niepotrzebne zużycie pamięci i czasu.

Sekwencje leniwe

Sekwencja przetwarza każdy element przez cały potok, zanim przejdzie do następnego. Nie są tworzone listy pośrednie. Konwersję wykonuje się za pomocą asSequence().

fun main() {
    val result = listOf(1, 2, 3, 4)
        .asSequence()
        .map { it * 2 }
        .filter { it > 4 }
        .toList()
    println(result)
}

Obserwowanie kolejności wykonywania

Dodanie instrukcji wypisywania pozwala zobaczyć różnicę. W przypadku sekwencji każdy element przechodzi przez map, a następnie filter, zanim rozpocznie się przetwarzanie kolejnego elementu.

fun main() {
    listOf(1, 2, 3).asSequence()
        .map { println("map $it"); it * 2 }
        .filter { println("filter $it"); it > 2 }
        .toList()
}

Kolejność wykonywania zachłannego

Dla porównania zwykła lista: map najpierw działa na WSZYSTKICH elementach, a dopiero potem filter działa na wszystkich elementach.

fun main() {
    listOf(1, 2, 3)
        .map { println("map $it"); it * 2 }
        .filter { println("filter $it"); it > 2 }
}

Wczesne zakończenie

Ewaluacja leniwa umożliwia wczesne zakończenie: operacje takie jak first lub find kończą działanie natychmiast po znalezieniu wyniku, unikając pracy na pozostałych elementach.

fun main() {
    val firstBig = (1..1000000).asSequence()
        .map { it * 2 }
        .first { it > 10 }
    println(firstBig)
}

Operacje pośrednie i terminalne

Operacje na sekwencjach dzielą się na dwa rodzaje:

Pośrednie (map, filter, take): leniwe, zwracają kolejną sekwencję.
Terminalne (toList, sum, first): uruchamiają obliczenia i zwracają wartość.

Bez operacji terminalnej nic się nie dzieje

Sam łańcuch operacji pośrednich nie uruchamia żadnego kodu. Dopóki nie zostanie wywołana operacja terminalna, lambdy nigdy się nie wykonają.

fun main() {
    val seq = listOf(1, 2, 3).asSequence()
        .map { println("processing $it"); it }
    println("Nothing printed yet")
    seq.toList()
}

Kiedy sekwencje są pomocne

Sekwencje sprawdzają się przy dużych zbiorach danych, długich łańcuchach operacji lub wtedy, gdy potrzebna jest tylko część wyniku (na przykład pierwszy pasujący element). W przypadku małych list zwykłe kolekcje są prostsze i równie szybkie.

Obrazowy model

Proszę wyobrazić sobie kolekcję jako przetwarzanie w warstwach poziomych (wszystkie elementy na każdym kroku), a sekwencję jako przetwarzanie w strumieniach pionowych (jeden element przechodzący przez wszystkie kroki). Dzięki temu sekwencje nie tworzą list pośrednich.

Szybkie sprawdzenie

Dlaczego sekwencje mogą być wydajniejsze niż kolekcje?

Podsumowanie

Sekwencje przetwarzają dane leniwie, element po elemencie, przez łańcuch operacji pośrednich, a obliczenia są uruchamiane dopiero przez operację terminalną. Pozwala to uniknąć list pośrednich i umożliwia wczesne zakończenie. Następnie nauczą się Państwo tworzyć sekwencje.

Często zadawane pytania

Czy lekcja „Dlaczego sekwencje” jest bezpłatna?

Tak — pełny tekst „Dlaczego sekwencje” 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 „Dlaczego sekwencje”?

Leniwa ewaluacja Ć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 1 z 4.

Ile czasu zajmuje lekcja „Dlaczego sekwencje”?

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

← Powrót do Kotlin Academy