Kotlin Academy · Leçon

Filtrage et mappage

Transformer des collections

Filtrage et mappage 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.

Transformer des collections

Les collections Kotlin proposent un riche ensemble d’opérations fonctionnelles. Les deux plus courantes sont filter (sélectionner des éléments) et map (transformer des éléments). Elles renvoient de nouvelles collections et ne modifient jamais l’originale.

La fonction filter

filter conserve uniquement les éléments qui satisfont un prédicat et renvoie une nouvelle liste.

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    val evens = numbers.filter { it % 2 == 0 }
    println(evens)
}

filterNot et filterNotNull

filterNot conserve les éléments qui ne correspondent pas à l’opération NOT. filterNotNull supprime les éléments nuls et renvoie une liste sans valeurs nulles.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    println(nums.filterNot { it > 2 })
    val withNulls = listOf(1, null, 3, null)
    println(withNulls.filterNotNull())
}

filterIndexed

filterIndexed vous fournit à la fois l’index et la valeur dans le prédicat.

fun main() {
    val letters = listOf("a", "b", "c", "d")
    val result = letters.filterIndexed { index, _ -> index % 2 == 0 }
    println(result)
}

La fonction map

map applique une transformation à chaque élément et renvoie une nouvelle liste contenant les résultats. Le type du résultat peut différer du type d’entrée.

fun main() {
    val numbers = listOf(1, 2, 3)
    val squares = numbers.map { it * it }
    println(squares)
}

Transformer vers un autre type

map peut modifier le type des éléments, par exemple en transformant des nombres en chaînes de caractères.

fun main() {
    val numbers = listOf(1, 2, 3)
    val labels = numbers.map { "Item $it" }
    println(labels)
}

mapIndexed

mapIndexed fournit l’index avec chaque élément, ce qui vous permet d’utiliser la position lors de la transformation.

fun main() {
    val fruits = listOf("apple", "banana", "cherry")
    val numbered = fruits.mapIndexed { i, fruit -> "${i + 1}. $fruit" }
    numbered.forEach { println(it) }
}

mapNotNull

mapNotNull transforme chaque élément et élimine les résultats nuls. C’est une manière claire de combiner transformation et filtrage.

fun main() {
    val strings = listOf("1", "two", "3", "four")
    val numbers = strings.mapNotNull { it.toIntOrNull() }
    println(numbers)
}

Enchaîner filter et map

Ces opérations se combinent naturellement. Un schéma courant consiste à filtrer d’abord, puis à transformer les éléments conservés.

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    val result = numbers
        .filter { it % 2 == 0 }
        .map { it * 10 }
    println(result)
}

Les opérations ne sont pas destructives

filter et map renvoient toutes deux des listes entièrement nouvelles. La collection d’origine reste inchangée, ce qui rend votre code plus sûr et plus facile à comprendre.

fun main() {
    val original = listOf(1, 2, 3)
    val doubled = original.map { it * 2 }
    println("Original: $original")
    println("Doubled: $doubled")
}

Filtrer et transformer en pratique

Ensemble, filter et map vous permettent d’exprimer des chaînes de traitement de données de manière déclarative : décrire WHAT vous voulez, et non HOW effectuer la boucle. Cette approche est plus claire que les boucles for écrites manuellement avec un suivi de l’index.

Vérification rapide

Quelle est la différence entre filter et map ?

Récapitulatif

Vous avez appris à sélectionner des éléments avec filter (et ses variantes filterNot, filterIndexed, filterNotNull) et à les transformer avec map (ainsi qu’avec mapIndexed et mapNotNull). Ces fonctions s’enchaînent proprement et ne modifient jamais la source. Vous allez maintenant organiser les données à l’aide du regroupement et du partitionnement.

Questions Fréquemment Posées

La leçon « Filtrage et mappage » est-elle gratuite ?

Oui — le texte complet de « Filtrage et mappage » 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 « Filtrage et mappage » ?

Transformer des collections 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 « Filtrage et mappage » ?

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

← Retour à Kotlin Academy