0Pricing
Kotlin Academy · Aula

Operadores de Flow: map, filter, transform e take

Aplique operadores intermediários para transformar e limitar as emissões de Flow.

Operadores de Flow: map, filter, transform e take é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 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.

O que é um fluxo

Um Flow é um fluxo assíncrono frio. Operadores intermediários como map, filter e transform são avaliados sob demanda — eles só são executados quando o fluxo é coletado.

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

Operador de mapeamento

map transforma cada valor emitido. É uma transformação de um para um aplicada de forma preguiçosa.

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

Operador de filtragem

filter mantém apenas os elementos que correspondem ao predicado, descartando os demais.

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
}

Operador de transformação

transform é o operador mais geral: você pode emitir zero, um ou vários valores para cada elemento de entrada.

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

Operador take

take(n) obtém apenas os primeiros n elementos e cancela o fluxo a montante depois disso.

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

takeWhile e dropWhile

takeWhile obtém elementos enquanto o predicado for verdadeiro; dropWhile descarta elementos até que o predicado se torne falso.

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
}

Encadeando operadores

Os operadores podem ser compostos: cada operador retorna um novo Flow, permitindo fluxos de processamento declarativos.

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 mapeia e descarta resultados nulos em uma só etapa — é equivalente a 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 mapeia cada elemento para um fluxo e concatena os resultados sequencialmente.

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

onEach para efeitos colaterais

onEach realiza um efeito colateral em cada elemento sem alterar o fluxo — é útil para registrar informações ou dados de análise em um fluxo de processamento.

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

O fluxo é frio

Cada chamada a collect reinicia o fluxo do zero. Nenhum elemento é emitido ou transformado até que um operador terminal inicie a coleta.

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
}

Verificação rápida

Qual operador emite zero, um ou vários valores para cada elemento do fluxo a montante?

Recapitulação

mapeia transforma de um para um; filtra descarta elementos; transforma emite qualquer quantidade; take limita a contagem. Encadeie-os de forma declarativa — o fluxo é frio e só é executado quando coletado.

Perguntas Frequentes

A aula “Operadores de Flow: map, filter, transform e take” é grátis?

Sim — o texto completo de “Operadores de Flow: map, filter, transform e take” é 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 “Operadores de Flow: map, filter, transform e take”?

Aplique operadores intermediários para transformar e limitar as emissões de Flow. 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 1 de 4.

Quanto tempo leva a aula “Operadores de Flow: map, filter, transform e take”?

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