0Pricing
Kotlin Academy · Lekcja

Operatory Flow: map, filter, transform i take

Stosuj operatory pośrednie do przekształcania i ograniczania emisji Flow.

Operatory Flow: map, filter, transform i take 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 jest Flow?

Flow to zimny, asynchroniczny strumień. Operatory pośrednie, takie jak map, filter i transform, są leniwe — wykonują się dopiero podczas zbierania elementów.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun numbers(): Flow<Int> = flow {
    repeat(5) { emit(it + 1) }
}
fun main() = runBlocking {
    numbers().collect { println(it) }
}

Operator map

map przekształca każdą emitowaną wartość. Jest to przekształcenie jeden-do-jednego stosowane leniwie.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..5).asFlow()
        .map { it * it }
        .collect { println(it) } // 1 4 9 16 25
}

Operator filter

filter przepuszcza tylko elementy spełniające predykat, odrzucając pozostałe.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..10).asFlow()
        .filter { it % 2 == 0 }
        .collect { println(it) } // 2 4 6 8 10
}

Operator transform

transform to najbardziej ogólny operator: dla każdego elementu wejściowego można wyemitować zero, jedną lub wiele wartości.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..3).asFlow()
        .transform { n ->
            emit("Item $n")
            emit("Done $n")
        }
        .collect { println(it) }
}

Operator take

take(n) pobiera tylko pierwszych n elementów, a następnie anuluje nadrzędny strumień Flow.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flow {
        repeat(100) { emit(it) }
    }.take(3)
     .collect { println(it) } // 0 1 2
}

takeWhile i dropWhile

takeWhile pobiera elementy, dopóki predykat ma wartość true; dropWhile odrzuca elementy, dopóki predykat nie przyjmie wartości false.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..10).asFlow()
        .takeWhile { it < 5 }
        .collect { println(it) } // 1 2 3 4

    (1..10).asFlow()
        .dropWhile { it < 5 }
        .collect { println(it) } // 5 6 7 8 9 10
}

Łączenie operatorów

Operatory można komponować: każdy operator zwraca nowy obiekt Flow, co umożliwia tworzenie deklaratywnych potoków przetwarzania.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..20).asFlow()
        .filter { it % 3 == 0 }
        .map { it * 2 }
        .take(4)
        .collect { println(it) } // 6 12 18 24
}

mapNotNull

mapNotNull przekształca wartości i odrzuca wyniki null w jednym kroku — jest równoważny wyrażeniu map + filter { it != null }.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flowOf("1", "two", "3", "four", "5")
        .mapNotNull { it.toIntOrNull() }
        .collect { println(it) } // 1 3 5
}

flatMapConcat

flatMapConcat przekształca każdy element w strumień Flow, a następnie sekwencyjnie łączy wyniki.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..3).asFlow()
        .flatMapConcat { n -> flowOf("$n-a", "$n-b") }
        .collect { println(it) }
}

onEach dla efektów ubocznych

onEach wykonuje efekt uboczny dla każdego elementu bez zmieniania strumienia — dobrze nadaje się do rejestrowania logów lub analityki w potoku przetwarzania.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..5).asFlow()
        .onEach { println("Processing: $it") }
        .filter { it % 2 == 0 }
        .collect { println("Collected: $it") }
}

Flow jest zimny

Każde wywołanie collect uruchamia strumień Flow od początku. Żaden element nie jest emitowany ani przekształcany, dopóki operator końcowy nie rozpocznie zbierania.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = (1..3).asFlow().map { println("map $it"); it * 2 }
    println("Before collect")
    flow.collect { println("got $it") }
    println("Second collect:")
    flow.collect { println("got $it") }  // runs again
}

Szybkie sprawdzenie

Który operator emituje zero, jedną lub wiele wartości dla każdego elementu nadrzędnego strumienia?

Podsumowanie

map przekształca elementy w relacji jeden-do-jednego; filter odrzuca elementy; transform emituje dowolną liczbę wartości; take ogranicza ich liczbę. Łącz je deklaratywnie — strumień Flow jest zimny i działa dopiero po rozpoczęciu zbierania.

Często zadawane pytania

Czy lekcja „Operatory Flow: map, filter, transform i take” jest bezpłatna?

Tak — pełny tekst „Operatory Flow: map, filter, transform i take” 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 „Operatory Flow: map, filter, transform i take”?

Stosuj operatory pośrednie do przekształcania i ograniczania emisji Flow. Ć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 „Operatory Flow: map, filter, transform i take”?

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

  1. Operatory Flow: map, filter, transform i take
  2. catch i onCompletion: obsługa błędów w Flow
  3. combine i zip: łączenie wielu Flow
  4. flowOn i buffer: kontekst i backpressure
← Powrót do Kotlin Academy