PricingLoginStart free
Kotlin Academy · Lektion

combine und zip: Mehrere Flows zusammenführen

Kombinieren Sie mehrere Flows und führen Sie ihre Emissionen mit zip zusammen.

Lektion 3 von 413 Schritte

combine und zip: Mehrere Flows zusammenführen ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Warum Flows zusammenführen?

In realen Anwendungen müssen häufig mehrere Datenströme kombiniert werden: Benutzereinstellungen und Netzwerkdaten, Formularfelder und Validierungsstatus. Kotlin Flow stellt dafür zip, combine und merge bereit.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val names = flowOf("Alice", "Bob", "Carol")
    val ages  = flowOf(30, 25, 35)
    names.zip(ages) { name, age -> "$name is $age" }
         .collect { println(it) }
}

zip: Gekoppelte Emissionen

zip koppelt Emissionen in der Reihenfolge paarweise. Der Operator endet, sobald der kürzere Flow abgeschlossen ist.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val a = flowOf(1, 2, 3, 4)   // 4 elements
    val b = flowOf("a", "b", "c")  // 3 elements — zip stops here
    a.zip(b) { n, s -> "$n-$s" }
     .collect { println(it) } // 1-a, 2-b, 3-c
}

combine: Aktuellste Werte

combine emittiert jedes Mal einen neuen Wert, wenn einer der Flows einen Wert emittiert, und verwendet dabei den aktuellsten Wert aus jedem Flow. Beide Flows müssen mindestens einmal einen Wert emittiert haben.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow1 = MutableStateFlow(1)
    val flow2 = MutableStateFlow("a")
    combine(flow1, flow2) { n, s -> "$n-$s" }
        .take(1)
        .collect { println(it) } // 1-a
}

Unterschied zwischen combine und zip

zip: wartet auf ein passendes Paar. combine: wird bei jeder Aktualisierung mit den aktuellsten Werten ausgelöst. Verwenden Sie combine für reaktive Benutzeroberflächen (z. B. zwei Formularfelder) und zip für die sequenzielle Zuordnung.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    // zip: 1-a, 2-b
    val nums = flowOf(1, 2).zip(flowOf("a", "b")) { n, s -> "$n-$s" }
    nums.collect { println("zip: $it") }

    // combine fires more:
    combine(flowOf(1, 2), flowOf("a")) { n, s -> "$n-$s" }
        .collect { println("combine: $it") }
}

merge: Ineinandergreifende Flows

merge emittiert Werte aus mehreren Flows, sobald sie eintreffen, ohne sie zu paaren — die Ausgabereihenfolge hängt vom Zeitpunkt der Emissionen ab.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val a = flow { emit("A1"); delay(50); emit("A2") }
    val b = flow { delay(25); emit("B1") }
    merge(a, b).collect { println(it) } // A1, B1, A2
}

combine mit mindestens 3 Flows

combine unterstützt mehrere Flows. Übergeben Sie sie als vararg; die Lambda-Funktion erhält alle aktuellsten Werte.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val a = MutableStateFlow("hello")
    val b = MutableStateFlow(42)
    val c = MutableStateFlow(true)
    combine(a, b, c) { s, n, flag -> "$s-$n-$flag" }
        .take(1)
        .collect { println(it) } // hello-42-true
}

flatMapMerge: Gleichzeitige innere Flows

flatMapMerge bildet jedes Element auf einen Flow ab und sammelt alle inneren Flows gleichzeitig, wobei ihre Ausgaben zusammengeführt werden.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..3).asFlow()
        .flatMapMerge { n ->
            flow { delay(100L - n * 10); emit("result-$n") }
        }
        .collect { println(it) }
}

flatMapLatest: Bei neuer Emission abbrechen

flatMapLatest bricht den aktuellen inneren Flow ab, sobald ein neues Element im vorgelagerten Flow eintrifft — ideal für die Suche während der Eingabe.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flowOf("k", "ko", "kot", "kotl", "kotli", "kotlin")
        .flatMapLatest { query ->
            flow {
                delay(50)  // simulate debounced search
                emit("Result for: $query")
            }
        }
        .collect { println(it) } // only "Result for: kotlin"
}

zip zum Zuordnen von Transaktionen

Verwenden Sie zip, um Ereignisse aus zwei Streams zu paaren, z. B. Benutzeraktionen mit Serverbestätigungen, und so eine 1:1-Zuordnung sicherzustellen.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val orders = flowOf("Order1", "Order2", "Order3")
    val confirmations = flowOf("Confirmed", "Confirmed", "Rejected")
    orders.zip(confirmations) { order, status -> "$order: $status" }
          .collect { println(it) }
}

combine zur Formularvalidierung

Kombinieren Sie Username- und Passwort-Flows, um die Gültigkeit des Formulars reaktiv zu berechnen — die Aktualisierung erfolgt, sobald sich eines der Felder ändert.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val username = MutableStateFlow("")
    val password = MutableStateFlow("")
    val isValid = combine(username, password) { u, p ->
        u.length >= 3 && p.length >= 8
    }
    username.value = "alice"
    password.value = "secure123"
    println(isValid.first()) // true
}

onEach + combine zum Laden aus mehreren Quellen

Kombinieren Sie ein Lade-Flag mit einem Datenfluss, um aus mehreren unabhängigen Quellen ein einzelnes UI-Zustandsobjekt zu erzeugen.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
data class UI(val loading: Boolean, val data: String)
fun main() = runBlocking {
    val loading = MutableStateFlow(true)
    val data    = MutableStateFlow("")
    combine(loading, data) { l, d -> UI(l, d) }
        .take(2)
        .collect { println(it) }
    data.value = "result"
    loading.value = false
}

Kurzer Test

Was ist der wichtigste Unterschied zwischen zip und combine?

Beantworte es in der interaktiven Lektion

Zusammenfassung

zip paart Emissionen in sequenzieller Reihenfolge; combine wird bei jeder Aktualisierung mit den aktuellsten Werten ausgelöst; merge lässt unabhängige Flows ineinandergreifen; flatMapLatest bricht veraltete innere Flows ab. Wählen Sie den Operator abhängig davon, ob Sie Paarbildung oder Reaktivität benötigen.

Kostenlos starten

Lerne Kotlin mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
51
Lektionen
203
Kostenlos lernenDen vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „combine und zip: Mehrere Flows zusammenführen“ kostenlos?

Ja — der vollständige Text von „combine und zip: Mehrere Flows zusammenführen“ 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 „combine und zip: Mehrere Flows zusammenführen“?

Kombinieren Sie mehrere Flows und führen Sie ihre Emissionen mit zip zusammen. 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 3 von 4.

Wie lange dauert die Lektion „combine und zip: Mehrere Flows zusammenführen“?

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