Kotlin List vers Map : guide de conversion et d'accélération du code

De la liste à la carte : pourquoi c'est important et comment bien faire ?

Imaginez la situation : vous travaillez sur une application en Kotlin, vous avez reçu une liste d'utilisateurs depuis une API. Vous devez trouver rapidement un utilisateur par son ID. Parcourir la liste à chaque fois — O(n), ce qui devient pénible avec 1000+ éléments. Alors que la recherche par Map — c'est O(1). La différence est colossale.

La question "How to convert List to Map in Kotlin?" est l'une des plus populaires sur Stack Overflow. Et pour cause : une mauvaise conversion peut entraîner une perte de données, une baisse de performance ou des bugs étranges. Aujourd'hui, nous allons analyser 5 méthodes de transformation, des plus simples aux plus avancées, et découvrir comment accélérer votre code jusqu'à 10 fois.

Approches de base : associate, toMap et groupBy

1. Classique : associate — le choix le plus fréquent

La fonction associate est le roi de la conversion. Elle prend un lambda qui retourne une paire (clé, valeur).

data class User(val id: Int, val name: String, val age: Int)\n\nval users = listOf(\n    User(1, "Анна", 25),\n    User(2, "Борис", 30),\n    User(3, "Виктор", 22)\n)\n\n// Cas le plus simple : id -> name\nval idToNameMap: Map<Int, String> = users.associate { it.id to it.name }\nprintln(idToNameMap) // {1=Анна, 2=Борис, 3=Виктор}\n\n// Objet complet par id\nval userMap: Map<Int, User> = users.associate { it.id to it }\nprintln(userMap[2]) // User(id=2, name="Борис", age=30)\n

Important : si la liste contient des clés en double (associate les écrase simplement avec la dernière), vous ne le remarquerez même pas. Soyez vigilant !

2. toMap — quand vous avez déjà une collection de paires

Si vous avez préalablement créé une liste de paires Pair<K, V>, utilisez toMap().

val pairs = listOf(\n    1 to "Анна",\n    2 to "Борис",\n    3 to "Виктор"\n)\n\nval mapFromPairs: Map<Int, String> = pairs.toMap()\nprintln(mapFromPairs) // {1=Анна, 2=Борис, 3=Виктор}\n

toMap fonctionne également avec les collections de Map.Entry et d'autres itérateurs de paires.

3. groupBy — quand une même clé correspond à plusieurs valeurs

Parfois, il est nécessaire de regrouper les éléments par clé. Par exemple, regrouper les utilisateurs par âge.

val usersByAge: Map<Int, List<User>> = users.groupBy { it.age }\n// Résultat : {25=[User(id=1, name=Анна, age=25)], 30=[User(id=2, name=Борис, age=30)], 22=[User(id=3, name=Виктор, age=22)]}\n

groupBy retourne un Map<K, List<V>>. Idéal pour l'analyse, le filtrage et la création de rapports.

Techniques avancées : quand les méthodes standard ne suffisent pas

4. associateBy — si vous avez besoin seulement de la clé, et que la valeur est l'élément lui-même

La fonction associateBy est un synonyme de associate { key to it }, mais se lit mieux.

val userMapById: Map<Int, User> = users.associateBy { it.id }\n// Équivalent à : users.associate { it.id to it }\nprintln(userMapById[1]) // User(id=1, name=Анна, age=25)\n

Conseil : utilisez associateBy lorsque vous devez créer un dictionnaire "clé → objet lui-même". Le code devient plus propre.

5. Conversion personnalisée avec gestion des doublons

Supposons que vous ayez une liste de commandes, et que plusieurs commandes puissent avoir le même ID (par exemple, différentes versions). Le associate standard les écrase simplement. Mais que faire si vous voulez toutes les conserver ?

data class Order(val id: Int, val amount: Double, val version: Int)\n\nval orders = listOf(\n    Order(1, 100.0, 1),\n    Order(1, 150.0, 2), // doublon d'id, mais version différente\n    Order(2, 200.0, 1)\n)\n\n// Option 1 : regroupement par id\nval ordersGrouped: Map<Int, List<Order>> = orders.groupBy { it.id }\n// {1=[Order(1, 100.0, 1), Order(1, 150.0, 2)], 2=[O