0Pricing
Kotlin Academy · Lektion

Flow-Operatoren: map, filter, transform und take

Wenden Sie Zwischenoperatoren an, um Flow-Emissionen umzuwandeln und zu begrenzen.

Flow-Operatoren: map, filter, transform und take ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Flow?

Ein Flow ist ein kalter, asynchroner Datenstrom. Zwischenoperatoren wie map, filter und transform sind träge – sie werden erst bei der Sammlung ausgeführt.

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

map-Operator

map transformiert jeden ausgegebenen Wert. Es handelt sich um eine faule 1:1-Transformation.

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

filter-Operator

filter lässt nur Elemente passieren, die dem Prädikat entsprechen, und verwirft den Rest.

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
}

transform-Operator

transform ist der allgemeinste Operator: Sie können pro Eingabeelement null, einen oder viele Werte ausgeben.

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

take-Operator

take(n) übernimmt nur die ersten n Elemente und bricht den Upstream-Flow anschließend ab.

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

takeWhile und dropWhile

takeWhile übernimmt Elemente, solange das Prädikat wahr ist; dropWhile verwirft Elemente, bis das Prädikat falsch wird.

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
}

Operatoren verketten

Operatoren lassen sich kombinieren: Jeder Operator gibt einen neuen Flow zurück und ermöglicht so deklarative Pipelines.

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 bildet Werte ab und verwirft Ergebnisse von null in einem Schritt – gleichbedeutend mit 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 bildet jedes Element auf einen Flow ab und fügt die Ergebnisse nacheinander zusammen.

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

onEach für Seiteneffekte

onEach führt für jedes Element einen Seiteneffekt aus, ohne den Datenstrom zu verändern – ideal für Logging oder Analytics in einer Pipeline.

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 ist kalt

Jeder Aufruf von collect startet den Flow von Anfang an neu. Kein Element wird ausgegeben oder transformiert, bevor ein Terminaloperator die Sammlung auslöst.

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
}

Kurze Überprüfung

Welcher Operator gibt pro Element des Upstream-Flows null, einen oder viele Werte aus?

Zusammenfassung

map transformiert 1:1; filter verwirft Elemente; transform gibt eine beliebige Anzahl aus; take begrenzt die Anzahl. Verketten Sie sie deklarativ – der Flow ist kalt und wird erst bei der Sammlung ausgeführt.

Häufig gestellte Fragen

Ist die Lektion „Flow-Operatoren: map, filter, transform und take“ kostenlos?

Ja — der vollständige Text von „Flow-Operatoren: map, filter, transform und take“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Flow-Operatoren: map, filter, transform und take“?

Wenden Sie Zwischenoperatoren an, um Flow-Emissionen umzuwandeln und zu begrenzen. Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Flow-Operatoren: map, filter, transform und take“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Flow-Operatoren: map, filter, transform und take
  2. catch und onCompletion: Fehlerbehandlung in Flow
  3. combine und zip: Mehrere Flows zusammenführen
  4. flowOn und buffer: Kontext und Backpressure
← Zurück zu Kotlin Academy