PricingLoginStart free
Kotlin Academy · Leçon

filter, map et find sur les collections

Appliquez des lambdas pour transformer et filtrer des collections à l’aide des fonctions de la bibliothèque standard.

Leçon 4 sur 413 étapes

filter, map et find sur les collections est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Trois fonctions essentielles

filter conserve les éléments correspondant à un prédicat. map transforme chaque élément. find renvoie le premier élément correspondant (ou null). Ensemble, ces fonctions couvrent la majeure partie du traitement des collections.

Principes de base de filter

filter renvoie une nouvelle liste contenant uniquement les éléments pour lesquels le prédicat est vrai.

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

Principes de base de map

map renvoie une nouvelle liste de même taille, dans laquelle chaque élément est transformé par la lambda.

fun main() {
    val nums = listOf(1, 2, 3)
    val squares = nums.map { it * it }
    println(squares) // [1, 4, 9]
}

Principes de base de find

find renvoie le premier élément correspondant au prédicat, ou null si aucun élément ne correspond.

fun main() {
    val words = listOf("apple", "banana", "cherry")
    val match = words.find { it.startsWith("b") }
    println(match) // banana
}

Chaîner filter et map

Combinez-les avec la syntaxe utilisant des points pour créer des chaînes de traitement expressives.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5)
    val result = nums.filter { it % 2 == 1 }.map { it * 10 }
    println(result) // [10, 30, 50]
}

Filtrer des classes de données

filter et map sont particulièrement utiles avec des collections d’instances de classes de données.

data class User(val name: String, val age: Int)
fun main() {
    val users = listOf(User("Ana", 17), User("Ben", 25), User("Cal", 31))
    val adultNames = users.filter { it.age >= 18 }.map { it.name }
    println(adultNames) // [Ben, Cal]
}

find ou first

find renvoie une valeur nullable ; first { ... } lève une exception si aucune correspondance n’est trouvée. Utilisez find pour les correspondances facultatives.

fun main() {
    val nums = listOf(1, 2, 3)
    println(nums.find { it > 10 })  // null
    // nums.first { it > 10 }       // throws NoSuchElementException
    println(nums.firstOrNull { it > 10 }) // null (alias of find)
}

filterNot et filterNotNull

filterNot inverse le prédicat. filterNotNull supprime les entrées null d’une liste de valeurs nullables.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    println(nums.filterNot { it % 2 == 0 }) // [1, 3]
    val maybe: List<String?> = listOf("a", null, "b", null, "c")
    println(maybe.filterNotNull()) // [a, b, c]
}

mapNotNull

mapNotNull transforme les éléments, puis supprime les valeurs null : cette fonction est pratique pour l’analyse.

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

Chaîne de traitement concrète

Un petit exemple combinant filter, map et une réduction finale.

data class Product(val name: String, val price: Double, val inStock: Boolean)
fun main() {
    val products = listOf(
        Product("Pen", 1.0, true),
        Product("Book", 12.0, false),
        Product("Lamp", 25.0, true)
    )
    val total = products
        .filter { it.inStock }
        .map { it.price }
        .sum()
    println("Available total: $total") // 26.0
}

Choisir entre les opérations

Utilisez filter lorsque vous voulez obtenir un sous-ensemble, map pour transformer les éléments, find pour rechercher une seule correspondance facultative, et chaînez-les lorsque nécessaire.

fun main() {
    val words = listOf("alpha", "beta", "gamma", "delta")
    println(words.filter { it.length == 5 })       // [alpha, gamma, delta]
    println(words.map { it.uppercase() })           // [ALPHA, BETA, GAMMA, DELTA]
    println(words.find { it.endsWith("ta") })       // beta
}

Vérification rapide

Quelle fonction renvoie une nouvelle collection dont les éléments ont été transformés par une lambda ?

Réponds-y dans la leçon interactive

Récapitulatif

filter sélectionne, map transforme et find localise la première correspondance (ou null). Combinez-les librement dans des chaînes de traitement : utilisez mapNotNull et filterNotNull pour gérer les valeurs facultatives.

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
51
Leçons
203
Commencer gratuitementVoir le cours complet

Questions Fréquemment Posées

La leçon « filter, map et find sur les collections » est-elle gratuite ?

Oui — le texte complet de « filter, map et find sur les collections » 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 « filter, map et find sur les collections » ?

Appliquez des lambdas pour transformer et filtrer des collections à l’aide des fonctions de la bibliothèque standard. 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 4 sur 4.

Combien de temps prend la leçon « filter, map et find sur les collections » ?

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. Qu’est-ce qu’une lambda ? Syntaxe et types
  2. Transmettre des lambdas à des fonctions
  3. it : le paramètre implicite
  4. filter, map et find sur les collections
← Retour à Kotlin Academy