0Pricing
Kotlin Academy · Aula

combine e zip: mesclando vários Flows

Combine vários Flows e agrupe suas emissões com zip.

combine e zip: mesclando vários Flows é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Por que mesclar fluxos?

Aplicativos reais frequentemente precisam combinar vários fluxos de dados: preferências do usuário + dados da rede, campos de formulário + estado de validação. O Fluxo do Kotlin fornece zip, combine e merge para isso.

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: emissões emparelhadas

zip emparelha as emissões uma a uma, na ordem. Ele para quando o fluxo mais curto termina.

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
}

combinar: valores mais recentes

combine emite um novo valor sempre que qualquer um dos fluxos emite, usando o valor mais recente de cada um. Ambos os fluxos precisam ter emitido pelo menos uma vez.

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
}

Diferença entre combinação e zip

zip: espera por um par correspondente. combine: é acionado a cada atualização usando os valores mais recentes. Use a combinação para interfaces reativas (por exemplo, dois campos de formulário) e zip para emparelhamento sequencial.

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") }
}

mesclar: fluxos intercalados

merge emite valores de vários fluxos à medida que chegam, sem emparelhá-los — a ordem da saída depende do momento das emissões.

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
}

combinar com 3 ou mais fluxos

combine oferece suporte a vários fluxos. Passe-os como vararg, e a lambda receberá todos os valores mais recentes.

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: fluxos internos simultâneos

flatMapMerge mapeia cada elemento para um fluxo e coleta todos os fluxos internos simultaneamente, mesclando suas saídas.

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: cancelar na nova emissão

flatMapLatest cancela o fluxo interno atual quando um novo elemento chega do upstream — perfeito para pesquisas enquanto se digita.

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 para emparelhar transações

Use zip para emparelhar eventos de dois fluxos: por exemplo, ações do usuário com confirmações do servidor, garantindo correspondência de um para um.

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) }
}

combinar para validação de formulário

Combine os fluxos de nome de usuário e senha para calcular reativamente a validade do formulário — ele é atualizado sempre que qualquer campo muda.

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 + combinação para carregamento de várias fontes

Combine um indicador de carregamento com um fluxo de dados para produzir um único objeto de estado da interface a partir de várias fontes independentes.

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
}

Verificação rápida

Qual é a principal diferença entre zip e combine?

Recapitulação

zip emparelha emissões sequencialmente; combinação é acionada em qualquer atualização usando os valores mais recentes; mesclagem intercala fluxos independentes; flatMapLatest cancela fluxos internos obsoletos. Escolha com base na necessidade de emparelhamento ou reatividade.

Perguntas Frequentes

A aula “combine e zip: mesclando vários Flows” é grátis?

Sim — o texto completo de “combine e zip: mesclando vários Flows” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “combine e zip: mesclando vários Flows”?

Combine vários Flows e agrupe suas emissões com zip. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “combine e zip: mesclando vários Flows”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Operadores de Flow: map, filter, transform e take
  2. catch e onCompletion: tratamento de erros em Flow
  3. combine e zip: mesclando vários Flows
  4. flowOn e buffer: contexto e contrapressão
← Voltar para Kotlin Academy