0Pricing
Kotlin Academy · Leçon

Opérateurs de Flow : map, filter, transform et take

Appliquez des opérateurs intermédiaires pour transformer et limiter les émissions de Flow.

Opérateurs de Flow : map, filter, transform et take est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce qu'un flux ?

Un Flow est un flux asynchrone froid. Les opérateurs intermédiaires comme map, filter et transform sont paresseux : ils ne s'exécutent que lors de la collecte.

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

Opérateur de projection

map transforme chaque valeur émise. Il s'agit d'une transformation un-à-un exécutée paresseusement.

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

Opérateur de filtrage

filter ne conserve que les éléments qui correspondent au prédicat et écarte les autres.

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
}

Opérateur de transformation

transform est l'opérateur le plus général : vous pouvez émettre zéro, une ou plusieurs valeurs pour chaque élément d'entrée.

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

Opérateur take

take(n) ne prend que les n premiers éléments, puis annule le flux en amont.

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

takeWhile et dropWhile

takeWhile prend les éléments tant que le prédicat est vrai ; dropWhile les ignore jusqu'à ce que le prédicat devienne faux.

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
}

Enchaînement des opérateurs

Les opérateurs se composent : chacun renvoie un nouveau Flow, ce qui permet de créer des chaînes de traitement déclaratives.

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 transforme les valeurs et élimine les résultats nuls en une seule étape — ce qui équivaut à 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 transforme chaque élément en flux, puis concatène les résultats séquentiellement.

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

onEach pour les effets secondaires

onEach applique un effet secondaire à chaque élément sans modifier le flux — ce qui convient à la journalisation ou à l'analyse dans une chaîne de traitement.

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

Le flux est froid

Chaque appel à collect redémarre le flux depuis le début. Aucun élément n'est émis ou transformé tant qu'un opérateur terminal ne déclenche pas la collecte.

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
}

Vérification rapide

Quel opérateur émet zéro, une ou plusieurs valeurs pour chaque élément en amont ?

Récapitulatif

La projection transforme les valeurs une à une ; le filtrage écarte les éléments ; la transformation en émet un nombre quelconque ; take en limite le nombre. Enchaînez-les de manière déclarative : le flux est froid et ne s'exécute que lors de la collecte.

Questions Fréquemment Posées

La leçon « Opérateurs de Flow : map, filter, transform et take » est-elle gratuite ?

Oui — le texte complet de « Opérateurs de Flow : map, filter, transform et take » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Opérateurs de Flow : map, filter, transform et take » ?

Appliquez des opérateurs intermédiaires pour transformer et limiter les émissions de Flow. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Opérateurs de Flow : map, filter, transform et take » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Opérateurs de Flow : map, filter, transform et take
  2. catch et onCompletion : gestion des erreurs dans Flow
  3. combine et zip : fusionner plusieurs Flows
  4. flowOn et buffer : contexte et contre-pression
← Retour à Kotlin Academy