Collections et lambdas

Ce que tu vas apprendre

• Distinguer List, Set et Map, en lecture seule ou modifiables.
• Écrire une lambda et la passer à une fonction.
• Transformer une liste avec filter et map.

Trois types de collections

Une collection regroupe plusieurs valeurs. Kotlin en propose trois principales.

val ingredients = listOf("farine", "oeufs", "lait", "oeufs")
val etapes = setOf(1, 2, 2, 3)
val temps = mapOf("tarte" to 50, "crêpes" to 20)

println(ingredients[0])    // farine
println(etapes)            // [1, 2, 3]
println(temps["tarte"])    // 50

mapOf prend des paires créées avec to. "tarte" to 50 équivaut à Pair("tarte", 50). Lire une clé avec [] renvoie une valeur nullable, puisque la clé peut manquer.

Lecture seule ou modifiable

val lecture: List<String> = listOf("sel", "poivre")
val modifiable: MutableList<String> = mutableListOf("sel")

modifiable.add("poivre")
// lecture.add("huile")   // erreur : List n'a pas de add()

List, Set et Map sont en lecture seule : on ne peut ni ajouter ni retirer. Leurs versions MutableList, MutableSet et MutableMap permettent de modifier le contenu.

La documentation recommande les types en lecture seule quand l'appelant n'a pas besoin de modifier la collection. Tu limites ainsi les surprises.

Parcourir une collection

for (nom in ingredients) {
    println(nom)
}

Tu connais déjà for. Kotlin offre aussi des fonctions qui font le travail à ta place, et elles reposent sur les lambdas.

Les lambdas

val majuscules = { texte: String -> texte.uppercase() }
println(majuscules("tarte"))   // TARTE

Une lambda est un petit morceau de code qu'on peut ranger dans une variable ou passer à une fonction. Elle s'écrit entre accolades : les paramètres, puis ->, puis le corps.

Une lambda sans paramètre s'écrit sans -> : { println("Bonjour") }. Sans type de paramètre explicite, Kotlin a besoin qu'il soit déduisible du contexte.

Passer une lambda à une fonction

val nombres = listOf(1, 2, 3, 4)
val somme = nombres.fold(0) { total, n -> total + n }
println(somme)   // 10

Quand la lambda est le dernier paramètre, on l'écrit après les parenthèses. C'est une lambda de fin. Si c'est le seul paramètre, les parenthèses disparaissent aussi.

filter et map

val minutes = listOf(10, 45, 20, 60)

val courtes = minutes.filter { it < 30 }
val enHeures = minutes.map { it / 60.0 }

println(courtes)   // [10, 20]

filter garde les éléments pour lesquels la lambda renvoie true. map transforme chaque élément et renvoie une nouvelle liste.

Quand la lambda a un seul paramètre, tu peux l'omettre et utiliser it. Tu peux aussi le nommer, comme dans { m -> m < 30 }, ce qui aide si le code devient long.

Ces fonctions ne modifient pas la liste d'origine. Elles renvoient toujours une nouvelle liste.

Enchaîner les opérations

Prenons une classe de recettes :

data class Recette(val titre: String, val minutes: Int)

val recettes = listOf(
    Recette("Crêpes", 20),
    Recette("Tarte", 50),
    Recette("Salade", 10)
)

val rapides = recettes
    .filter { it.minutes <= 30 }
    .map { it.titre }

println(rapides)   // [Crêpes, Salade]

Chaque appel part du résultat du précédent. On lit la chaîne comme une phrase : « garde les recettes de 30 minutes ou moins, puis prends leur titre ».

Une lambda en retour

fun convertisseur(unite: String): (Int) -> Int = when (unite) {
    "heure" -> { v -> v * 60 }
    else -> { v -> v }
}

println(convertisseur("heure")(2))   // 120

Une fonction peut renvoyer une lambda. Son type de retour s'écrit alors comme un type de fonction : (Int) -> Int signifie « prend un Int, renvoie un Int ».

À retenir

• List est ordonnée, Set garde des éléments uniques, Map associe des clés à des valeurs.
• listOf, setOf et mapOf créent des collections en lecture seule ; mutableListOf et ses équivalents permettent la modification.
• Une lambda s'écrit { parametre -> corps } et peut être passée à une fonction.
• Une lambda placée en dernier paramètre s'écrit après les parenthèses.
• filter garde des éléments, map les transforme : toutes deux renvoient une nouvelle liste.
• it désigne l'unique paramètre d'une lambda quand on ne le nomme pas.