Android Academy · Leçon

Tables associatives et ensembles

Collections de paires clé-valeur et de valeurs uniques.

Tables associatives et ensembles est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 4 leçons au total.

Maps et ensembles

Une map stocke des paires clé-valeur : chaque clé unique pointe vers une valeur, comme dans un dictionnaire.

Un set stocke des éléments uniques, sans doublons et sans ordre garanti.

Les deux sont des types de collections complémentaires aux listes, utiles lorsque vous avez besoin de recherches ou d'unicité.

Créer une map

Utilisez mapOf() avec des paires key to value pour créer une map en lecture seule.

Les clés doivent être uniques. Ici, nous associons des noms de fruits à des prix.

fun main() {
    val prices = mapOf("apple" to 3, "banana" to 2)
    println(prices)
    println("Size: ${prices.size}")
}

Rechercher des valeurs

Lisez une valeur avec des crochets et une clé. Si la clé est absente, vous obtenez null.

Utilisez l'opérateur Elvis ?: pour fournir une valeur par défaut lorsqu'une clé est absente.

fun main() {
    val prices = mapOf("apple" to 3, "banana" to 2)
    println(prices["apple"])
    println(prices["cherry"] ?: "not found")
}

Parcourir une map

Une boucle for sur une map vous fournit chaque entrée. Vous pouvez la déstructurer en key et value.

C'est la manière habituelle de traiter chaque paire.

fun main() {
    val ages = mapOf("Ada" to 36, "Bob" to 24)
    for ((name, age) in ages) {
        println("$name is $age")
    }
}

Maps mutables

Utilisez mutableMapOf() lorsque vous devez ajouter ou modifier des entrées.

Affecter une valeur à une nouvelle clé l'insère ; l'affecter à une clé existante remplace sa valeur.

fun main() {
    val stock = mutableMapOf("pens" to 5)
    stock["books"] = 10
    stock["pens"] = 8
    println(stock)
}

Supprimer une entrée d'une map

Appelez remove() avec une clé pour supprimer cette entrée d'une map mutable.

Utilisez containsKey() pour vérifier qu'une clé existe avant de vous y fier.

fun main() {
    val m = mutableMapOf("a" to 1, "b" to 2)
    m.remove("a")
    println(m.containsKey("a"))
    println(m)
}

Clés et valeurs

Chaque map expose les collections keys et values.

Utilisez-les lorsque seule l'une des deux parties des paires vous intéresse.

fun main() {
    val prices = mapOf("apple" to 3, "banana" to 2)
    println(prices.keys)
    println(prices.values)
}

Créer un ensemble

Utilisez setOf() pour créer un ensemble en lecture seule. Les valeurs en double sont automatiquement supprimées.

Les ensembles sont ainsi parfaits pour regrouper des éléments uniques.

fun main() {
    val tags = setOf("kotlin", "android", "kotlin")
    println(tags)
    println("Size: ${tags.size}")
}

Vérification de l’appartenance

Les ensembles sont particulièrement efficaces pour vérifier rapidement l’appartenance. Utilisez in ou contains() pour vérifier si une valeur est présente.

Vérifier un ensemble est généralement plus rapide que parcourir une liste.

fun main() {
    val allowed = setOf("admin", "editor")
    println("admin" in allowed)
    println(allowed.contains("guest"))
}

Ensembles modifiables et dédoublonnage

Utilisez mutableSetOf() pour construire un ensemble progressivement. Ajouter une valeur déjà présente ne produit aucun effet.

Astuce rapide : appelez toSet() sur une liste pour supprimer les doublons.

fun main() {
    val nums = listOf(1, 2, 2, 3, 3, 3)
    val unique = nums.toSet()
    println(unique)
}

Map ou ensemble

Utilisez une map lorsque vous devez associer des clés à des valeurs, par exemple un nom d’utilisateur à un profil.

Utilisez un ensemble lorsque vous voulez seulement savoir si un élément existe, sans autoriser les doublons.

Vérification rapide

Vérifiez votre compréhension des maps et des ensembles.

Récapitulatif

Les maps stockent des paires clé-valeur avec mapOf() / mutableMapOf() ; effectuez une recherche par clé et gérez les clés absentes avec ?:.

Les ensembles stockent des éléments uniques avec setOf() / mutableSetOf() et permettent de vérifier rapidement l’appartenance.

Questions Fréquemment Posées

La leçon « Tables associatives et ensembles » est-elle gratuite ?

Oui — le texte complet de « Tables associatives et ensembles » 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 Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tables associatives et ensembles » ?

Collections de paires clé-valeur et de valeurs uniques. Tu pratiques Android 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 Android Academy ?

Aucune expérience préalable n'est requise. Android 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 2 sur 4.

Combien de temps prend la leçon « Tables associatives et ensembles » ?

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 Android Academy ?

Oui. Chaque leçon Android 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 à Android Academy