C# Academy · Leçon

Les listes en pratique

Ajoutez, supprimez et recherchez.

Les listes en pratique est une leçon C# 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 C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Pourquoi utiliser une liste générique

List<T> est le tableau dynamique courant en C#. Il se trouve dans System.Collections.Generic et s'agrandit automatiquement lorsque vous ajoutez des éléments.

Contrairement à un tableau classique, vous n'avez jamais besoin de définir une taille fixe à l'avance. Ses types sont vérifiés : une List<int> ne contient que des valeurs int, ce qui est contrôlé à la compilation.

using System.Collections.Generic;

List<int> scores = new List<int>();
scores.Add(90);
scores.Add(85);

Créer et initialiser

Vous pouvez remplir une liste immédiatement à l'aide d'un initialiseur de collection. Cette syntaxe est concise et lisible.

Le compilateur transforme chaque entrée en appel à Add en arrière-plan, si bien que le résultat est identique à l'ajout des éléments un par un.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var fruits = new List<string> { "apple", "pear", "plum" };
        Console.WriteLine(fruits.Count);
    }
}

Indexation et nombre d'éléments

Accédez aux éléments avec un index commençant à zéro, comme pour un tableau. list[0] est le premier élément.

Utilisez Count, et non Length, pour connaître le nombre d'éléments de la liste. La lecture ou l'écriture par index s'effectue en temps constant O(1).

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 10, 20, 30 };
        Console.WriteLine(nums[1]);
        Console.WriteLine(nums.Count);
    }
}

Ajouter et insérer

Add ajoute un élément à la fin en temps O(1) amorti. AddRange ajoute plusieurs éléments en une seule fois.

Insert(index, item) place un élément à une position donnée et décale tout ce qui le suit. Ce décalage rend l'insertion au début coûteuse, en O(n) : lorsque c'est possible, préférez ajouter les éléments à la fin.

var list = new List<string> { "b", "c" };
list.Insert(0, "a");
list.AddRange(new[] { "d", "e" });
// list is now a, b, c, d, e

Supprimer des éléments

Remove(item) supprime la première valeur correspondante et renvoie true si elle a été trouvée. RemoveAt(index) supprime un élément selon sa position.

Les deux méthodes décalent les éléments suivants vers la gauche, donc une suppression au milieu coûte O(n). RemoveAll accepte un prédicat et supprime toutes les correspondances en un seul parcours.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 1, 2, 3, 4, 5 };
        nums.RemoveAll(n => n % 2 == 0);
        Console.WriteLine(string.Join(",", nums));
    }
}

Rechercher dans une liste

Contains indique si une valeur existe ; IndexOf renvoie sa position ou -1. Les deux méthodes parcourent la liste linéairement, en O(n).

Si vous recherchez régulièrement une valeur dans une grande liste, ce coût linéaire finit par s'accumuler. Un HashSet ou un Dictionary peut être plus adapté.

var names = new List<string> { "Ann", "Bob", "Cy" };
bool hasBob = names.Contains("Bob");   // true
int pos = names.IndexOf("Cy");          // 2

Parcourir

Une boucle foreach est la manière la plus claire de lire chaque élément. Vous pouvez également utiliser une boucle classique for lorsque vous avez besoin de l'index.

N'ajoutez ni ne supprimez d'éléments dans une boucle foreach parcourant la même liste : cela lève une InvalidOperationException.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var colors = new List<string> { "red", "green", "blue" };
        foreach (var c in colors)
            Console.WriteLine(c);
    }
}

Trier

Sort() trie la liste sur place à l'aide du comparateur par défaut. Pour appliquer un ordre personnalisé, transmettez un délégué de comparaison.

Le tri coûte O(n log n). Pour obtenir une copie triée sans modifier l'originale, utilisez OrderBy de LINQ, qui renvoie une nouvelle séquence.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var nums = new List<int> { 4, 1, 3, 2 };
        nums.Sort();
        Console.WriteLine(string.Join(",", nums));
    }
}

Capacité et nombre d'éléments

Count indique le nombre d'éléments présents ; Capacity indique combien d'éléments la liste peut contenir avant de réallouer son tableau interne.

Lorsque la liste dépasse sa capacité, elle alloue un tableau plus grand et y copie les éléments, en doublant environ la taille. Si vous connaissez la taille finale, transmettez-la au constructeur pour éviter les copies répétées.

var list = new List<int>(1000); // reserve capacity
for (int i = 0; i < 1000; i++)
    list.Add(i);
// no intermediate reallocations

Liste comme argument de méthode

Une List<T> est un type référence. La transmettre à une méthode revient à transmettre la référence, de sorte que les modifications effectuées dans la méthode affectent la liste de l'appelant.

Si une méthode ne fait que lire, acceptez IEnumerable<T> ou IReadOnlyList<T> pour indiquer que vous ne la modifierez pas.

using System;
using System.Collections.Generic;

class Program {
    static void AddOne(List<int> xs) => xs.Add(1);
    static void Main() {
        var nums = new List<int>();
        AddOne(nums);
        Console.WriteLine(nums.Count); // 1
    }
}

Convertir et copier

ToArray() produit un tableau de taille fixe ; new List<T>(other) crée une copie superficielle d'une autre séquence.

Une copie superficielle duplique la structure de la liste, mais partage les mêmes références vers les éléments. Ainsi, la modification d'un objet contenu est visible dans les deux listes.

var original = new List<int> { 1, 2, 3 };
int[] arr = original.ToArray();
var copy = new List<int>(original);

Vérification rapide

Repérez l'opération la plus coûteuse.

Récapitulatif

List<T> est un tableau extensible dont les types sont vérifiés. L'accès par index et Count s'effectuent en O(1) ; Add à la fin coûte O(1) amorti.

L'insertion, la suppression et la recherche d'une valeur au milieu coûtent O(n) en raison des décalages ou du parcours. Réservez la capacité lorsque la taille est connue afin d'éviter les réallocations.

Questions Fréquemment Posées

La leçon « Les listes en pratique » est-elle gratuite ?

Oui — le texte complet de « Les listes en pratique » 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 C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Les listes en pratique » ?

Ajoutez, supprimez et recherchez. Tu pratiques C# 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 C# Academy ?

Aucune expérience préalable n'est requise. C# 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 « Les listes en pratique » ?

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 C# Academy ?

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