Kotlin Academy · Leçon

Classes de données dans les collections et comme clés de map

Utilisez des classes de données dans des ensembles et des maps en tirant parti de l’égalité structurelle.

Leçon 4 sur 413 étapes

Classes de données dans les collections et comme clés de map 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.

Les classes de données comme objets-valeurs

Parce que les classes de données redéfinissent structurellement equals et hashCode, elles fonctionnent parfaitement dans les ensembles et comme clés de map, contrairement aux classes ordinaires.

Classe ordinaire : mauvaise clé de map

Une classe ordinaire utilise par défaut l’égalité de référence. Deux objets qui semblent identiques sont des clés de map différentes.

class Key(val id: Int)  // no equals/hashCode
val map = mutableMapOf<Key, String>()
val k1 = Key(1)
val k2 = Key(1)  // same id, different object
map[k1] = "value"
println(map[k2])  // null! k2 != k1 by reference

Classe de données : clé de map correcte

Une classe de données utilise l’égalité structurelle. Deux objets possédant les mêmes propriétés sont égaux.

data class Key(val id: Int)
val map = mutableMapOf<Key, String>()
val k1 = Key(1)
val k2 = Key(1)
map[k1] = "value"
println(map[k2])  // "value"! Equal by value

Classe de données dans un ensemble

Les ensembles utilisent equals et hashCode pour supprimer les doublons. Les classes de données suppriment correctement les doublons.

data class Tag(val name: String)
val tags = mutableSetOf<Tag>()
tags.add(Tag("kotlin"))
tags.add(Tag("kotlin"))  // duplicate
tags.add(Tag("java"))
println(tags.size)  // 2 (not 3)

GroupBy avec des classes de données

Regroupez des collections à l’aide d’une clé issue d’une classe de données.

data class Category(val name: String, val parent: String)
val items = listOf(
    "List" to Category("Collections", "stdlib"),
    "Map" to Category("Collections", "stdlib"),
    "Flow" to Category("Coroutines", "kotlinx")
)
val grouped = items.groupBy { it.second }
println(grouped.keys.size)  // 2

Compter les occurrences avec une map

Comptez les occurrences de données structurées en utilisant une classe de données comme clé de map.

data class Pair2(val x: Int, val y: Int)
val points = listOf(Pair2(1,2), Pair2(1,2), Pair2(3,4))
val counts = points.groupingBy { it }.eachCount()
println(counts)  // {Pair2(x=1, y=2)=2, Pair2(x=3, y=4)=1}

Classes de données imbriquées

Les classes de données peuvent contenir d’autres classes de données. Pour les classes de données imbriquées, equals et hashCode sont calculés en profondeur.

data class Address(val city: String, val country: String)
data class Person(val name: String, val address: Address)
val p1 = Person("Alice", Address("Berlin", "DE"))
val p2 = Person("Alice", Address("Berlin", "DE"))
println(p1 == p2)  // true

sortedBy avec des classes de données

Triez une liste d’instances de classes de données selon une propriété.

data class Student(val name: String, val grade: Double)
val students = listOf(
    Student("Bob", 3.2),
    Student("Alice", 3.8),
    Student("Charlie", 2.9)
)
println(students.sortedBy { it.grade })

Classes de données et mise en cache

Utilisez des classes de données comme clés de cache dans une HashMap lorsque la clé de cache est composite.

data class CacheKey(val userId: Long, val resourceType: String)
val cache = HashMap<CacheKey, ByteArray>()
val key = CacheKey(42, "avatar")
cache[key] = byteArrayOf(1, 2, 3)
println(cache[CacheKey(42, "avatar")] != null)  // true

distinct sur les classes de données

distinct() appliqué à une liste de classes de données utilise leur méthode equals pour supprimer les doublons.

data class Event(val type: String, val ts: Long)
val events = listOf(
    Event("click", 1000),
    Event("click", 1000),  // duplicate
    Event("scroll", 2000)
)
println(events.distinct().size)  // 2

Les clés immuables sont plus sûres

Utilisez toujours des classes de données dont les propriétés sont des val comme clés de map ou d’ensemble. Modifier une clé après son insertion endommage la structure de données.

data class ImmutableKey(val id: Int)  // val properties only
// DON'T: data class MutableKey(var id: Int)  // changing id breaks map!

Vérification rapide

Pourquoi les classes de données fonctionnent-elles correctement comme clés de map alors que les classes ordinaires ne le font souvent pas ?

Réponds-y dans la leçon interactive

Récapitulatif

Les classes de données fonctionnent comme clés de map et éléments d’ensemble parce qu’elles possèdent des implémentations correctes de equals et hashCode structurels. Utilisez des propriétés val pour conserver des clés immuables. Exploitez groupBy, distinct et sortedBy avec les classes de données pour effectuer des requêtes puissantes.

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 gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Classes de données dans les collections et comme clés de map » est-elle gratuite ?

Oui — le texte complet de « Classes de données dans les collections et comme clés de map » 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 « Classes de données dans les collections et comme clés de map » ?

Utilisez des classes de données dans des ensembles et des maps en tirant parti de l’égalité structurelle. 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 « Classes de données dans les collections et comme clés de map » ?

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

Notions de base des classes de données : méthodes générées automatiquement
Copier avec copy() et redéfinitions partielles
Déclarations déstructurées avec componentN
Classes de données dans les collections et comme clés de map

← Retour à Kotlin Academy