Android Academy · Leçon

Listes et listes mutables

Stockez des données ordonnées.

Listes et listes mutables est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Qu'est-ce qu'une liste ?

Une liste est une collection ordonnée d'éléments. Chaque élément possède une position, appelée index, qui commence à 0.

En Kotlin, les listes existent sous deux formes : les listes en lecture seule, que vous ne pouvez pas modifier, et les listes mutables, auxquelles vous pouvez ajouter des éléments ou dont vous pouvez supprimer des éléments.

Les listes sont partout dans les applications Android : fil d'actualités, ligne de boutons, résultats de recherche.

Créer une liste en lecture seule

Utilisez listOf() pour créer une liste en lecture seule. Une fois créée, vous ne pouvez plus y ajouter ni en supprimer d'éléments.

C'est le choix par défaut le plus sûr. Si vos données ne changent jamais, privilégiez une liste en lecture seule.

fun main() {
    val fruits = listOf("apple", "banana", "cherry")
    println(fruits)
    println("Size: ${fruits.size}")
}

Accéder aux éléments par index

Lisez un élément avec des crochets et son index. Le premier élément se trouve à l'index 0.

Vous pouvez également utiliser first() et last() pour accéder aux extrémités de la liste.

fun main() {
    val colors = listOf("red", "green", "blue")
    println(colors[0])
    println(colors.first())
    println(colors.last())
}

Parcourir une liste

La boucle for parcourt chaque élément dans l'ordre. C'est la manière la plus courante de traiter tous les éléments.

Ici, nous affichons chaque nom sur sa propre ligne.

fun main() {
    val names = listOf("Ada", "Linus", "Grace")
    for (name in names) {
        println("Hello, $name")
    }
}

Créer une liste mutable

Lorsque vous devez modifier le contenu, utilisez mutableListOf(). Cette fonction vous permet d'ajouter et de supprimer des éléments après la création de la liste.

Utilisez add() pour ajouter un élément à la fin.

fun main() {
    val tasks = mutableListOf("wake up", "code")
    tasks.add("sleep")
    println(tasks)
}

Supprimer des éléments

Utilisez remove() pour supprimer une valeur précise, ou removeAt() pour supprimer un élément par son index.

Ces deux fonctions ne fonctionnent qu'avec les listes mutables. Les appeler sur une liste en lecture seule provoque une erreur de compilation.

fun main() {
    val nums = mutableListOf(10, 20, 30, 40)
    nums.remove(20)
    nums.removeAt(0)
    println(nums)
}

Mettre à jour un élément

Dans une liste mutable, affectez une nouvelle valeur à un index pour remplacer l'élément existant.

L'index doit déjà exister ; sinon, une erreur d'index hors limites se produit.

fun main() {
    val scores = mutableListOf(5, 8, 3)
    scores[1] = 99
    println(scores)
}

Vérifier le contenu

Utilisez contains() ou le mot-clé in pour vérifier qu'une liste contient une valeur.

Utilisez isEmpty() pour vérifier qu'une liste ne contient aucun élément. Ces fonctions fonctionnent avec les deux types de listes.

fun main() {
    val pets = listOf("cat", "dog")
    println("cat" in pets)
    println(pets.contains("fish"))
    println(pets.isEmpty())
}

Types en lecture seule et mutables

Le type List<T> est en lecture seule. Le type MutableList<T> ajoute des opérations de modification.

Une pratique courante consiste à construire une liste avec un type mutable, puis à l'exposer comme une List en lecture seule afin que les autres parties du code ne puissent pas la modifier.

val safe: List<Int> = mutableListOf(1, 2, 3)
// safe.add(4) would NOT compile

Taille et index

La propriété size vous indique combien d'éléments contient une liste.

Les index valides vont de 0 à size - 1. Utilisez indices pour parcourir les positions.

fun main() {
    val items = listOf("a", "b", "c")
    for (i in items.indices) {
        println("$i -> ${items[i]}")
    }
}

Ajouter plusieurs éléments à la fois

Utilisez addAll() pour ajouter à une liste mutable tous les éléments d'une autre collection.

C'est pratique pour fusionner des résultats, par exemple pour combiner deux pages de données.

fun main() {
    val list = mutableListOf(1, 2)
    list.addAll(listOf(3, 4, 5))
    println(list)
    println("Total: ${list.size}")
}

Vérification rapide

Vérifiez votre compréhension des listes Kotlin.

Récapitulatif

Vous avez appris que les listes sont ordonnées et indexées à partir de 0. listOf() crée des listes en lecture seule ; mutableListOf() crée des listes modifiables.

Vous pouvez ajouter, supprimer, mettre à jour et parcourir les éléments, ainsi qu'en vérifier le contenu. Privilégiez les listes en lecture seule, sauf si vous devez réellement les modifier.

Questions Fréquemment Posées

La leçon « Listes et listes mutables » est-elle gratuite ?

Oui — le texte complet de « Listes et listes mutables » 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 « Listes et listes mutables » ?

Stockez des données ordonnées. 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 1 sur 4.

Combien de temps prend la leçon « Listes et listes mutables » ?

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