Liste : List<T>

1. Introduction

Imagine que tu fais une liste de courses. Aujourd’hui tu dois acheter 3 trucs, demain 10, et après-demain juste un seul. Si tu utilisais un tableau, il faudrait à chaque fois créer un nouveau tableau pour le nombre exact d’articles. Ou alors tu crées un tableau énorme "au cas où", et tu te retrouves à "porter" plein de cases vides. Pas super efficace, non ?

Maintenant, imagine que t’as un sac à dos magique qui s’agrandit tout seul quand tu rajoutes des trucs dedans, et qui rétrécit quand tu les retires. Pas besoin de savoir à l’avance combien tu vas en mettre. Tu balances tes affaires, et le sac s’adapte. Voilà, c’est exactement ça List<T> dans le monde du dev C# !

List<T> — c’est une collection générique qui te permet de stocker une séquence d’éléments d’un certain type. Le mot-clé ici, c’est "dynamique". Contrairement aux tableaux, List<T> peut changer de taille pendant que ton programme tourne. Il gère tout seul sa capacité interne, et l’augmente si besoin.

Qu’est-ce que ça veut dire le T dans List<T> ? C’est ce qu’on appelle un paramètre de type. Quand tu crées une List, tu précises quel type de données elle va contenir à la place de T. Par exemple, List<int> va contenir que des entiers, List<string> — que des chaînes de caractères, et List<double> — que des nombres à virgule. Comme ça, tu risques pas de mettre une pomme dans une liste d’oranges, ce qui est super important pour la stabilité et la prévisibilité de ton code.

Pourquoi on en a besoin ?

Dans les vrais projets, c’est super courant de pas savoir à l’avance combien d’éléments tu vas avoir. Par exemple :

• La liste des utilisateurs connectés sur un site.
• La liste des articles dans le panier d’une boutique en ligne.
• La liste des résultats d’une recherche.
• La liste des tâches dans un planificateur, qu’on va justement coder maintenant.

Dans tous ces cas, le nombre d’éléments peut changer, et List<T> devient ton meilleur pote.

Méthodes principales de List<T>

Add(T item)

numbers.Add(5);

Insert(int idx, T)

numbers.Insert(0, 42);

Remove(T item)

numbers.Remove(100);

RemoveAt(int idx)

numbers.RemoveAt(2);

Clear()

numbers.Clear();

Contains(T item)

numbers.Contains(10);

IndexOf(T item)

int pos = numbers.IndexOf(42);

Count

int n = numbers.Count;

Capacity

numbers.Capacity = 100;

2. Créer une liste (List<T>)

On passe à la pratique ! Imagine qu’on veut faire un petit gestionnaire de tâches. Il nous faut une liste où on va ajouter nos trucs à faire.

Pour créer une nouvelle List<T>, on utilise l’opérateur new, comme pour n’importe quel autre objet.

Comment déclarer et créer une List

La syntaxe ressemble à celle d’un tableau, sauf qu’on met des chevrons à la place des crochets :

using System.Collections.Generic;

List<int> numbers = new List<int>();

Pour ceux qui aiment les détails :
- List<int> — c’est une liste d’entiers (int). À la place de int, tu peux mettre n’importe quel type : string, double, ta propre classe, etc.
- Quand tu viens de la créer, la liste est vide — sa longueur est 0.

Exemple : premier pas dans notre appli

Imaginons qu’on a une appli où l’utilisateur entrait son nom et son âge (depuis les premiers cours). Maintenant, on va ajouter la possibilité de sauvegarder plusieurs noms dans une liste, pour pouvoir les manipuler après.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> names = new List<string>();

        Console.WriteLine("Tape trois prénoms :");
        for (int i = 0; i < 3; i++)
        {
            string name = Console.ReadLine();
            names.Add(name);
        }

        Console.WriteLine("Tu as tapé :");
        foreach (string n in names)
        {
            Console.WriteLine(n);
        }
    }
}

Regarde bien Add(). C’est cette méthode qui ajoute de nouveaux éléments à la liste. C’est ça qui la rend dynamique !

On peut créer une liste direct avec des éléments !

List<string> planets = new List<string> { "Mercure", "Vénus", "Terre" };

Super pratique quand tu connais déjà la "composition de départ". Cette syntaxe est souvent utilisée dans les tests ou pour initialiser des données fixes.

3. Opérations de base avec List<T>

Avant de passer aux astuces et à la magie, voyons l’"alphabet" de la liste.

Ajouter des éléments : Add()

Utiliser Add(), c’est comme poser un nouvel objet sur une étagère :

List<int> numbers = new List<int>();
numbers.Add(42);
numbers.Add(100);

Maintenant dedans : [42, 100]

Obtenir le nombre d’éléments : Count

Contrairement au tableau, la propriété s’appelle pas Length, mais Count :

int count = numbers.Count; // Ça renverra 2

À retenir : pour les listes c’est Count, pour les tableaux et les chaînes c’est Length. C’est pas pareil, même si ça sert à peu près à la même chose.

Accéder aux éléments par index

Deux façons, c’est pareil au final :

int first = numbers[0]; // 42
numbers[1] = 200; // On remplace 100 par 200

Important : L’indexation commence à zéro, comme pour les tableaux. Essaie pas d’accéder à numbers[3] si t’as que trois éléments !

Parcourir les éléments de la liste

Tu peux utiliser une boucle for ou foreach :

// Avec for — si t’as besoin de l’index
for (int i = 0; i < numbers.Count; i++)
{
    Console.WriteLine(numbers[i]);
}

// Avec foreach — si t’as pas besoin de l’index
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

foreach est souvent plus simple et plus lisible, surtout pour les grosses collections.
Mais avec, tu peux pas modifier les éléments par index ou sortir de la boucle avec break, sauf si tu utilises des trucs en plus.

Insérer un élément à un index : Insert()

La méthode Insert() sert si tu veux ajouter un élément pas à la fin, mais n’importe où. Par exemple, en deuxième position :

numbers.Insert(1, 55); // Insère 55 à l’index 1

Maintenant numbers : [42, 55, 200]

Supprimer des éléments

Supprimer d’une liste, c’est presque aussi simple qu’ajouter :

numbers.Remove(55); // Supprime la PREMIÈRE occurrence de 55
numbers.RemoveAt(0); // Supprime l’élément à l’index 0
numbers.Clear(); // Vide complètement la liste

À savoir sur la suppression :
- Si tu supprimes une valeur qui existe pas avec Remove, rien de grave : la liste change pas, pas d’erreur.
- Après Clear(), la liste est à nouveau vide.

4. Astuces utiles

Comment List<T> grandit

Quand tu ajoutes des éléments à List<T>, elle augmente pas sa taille à chaque fois un tout petit peu. En fait, List<T> réserve d’avance un bloc mémoire (la capacité interne — Capacity).

Dès que t’as plus d’éléments que la capacité actuelle, la liste alloue un nouveau bloc mémoire plus grand (en général 2 fois plus) et copie dedans toutes les anciennes valeurs :

On ajoute des éléments → ça rentre → ça rentre → ça rentre →
Un nouvel élément rentre pas → on crée un tableau plus grand → on copie les données → on continue

Ça permet d’ajouter des éléments plus vite, parce que la mémoire est réallouée que de temps en temps, pas à chaque Add.

var list = new List<int>();    // Capacity = 0
list.Add(1);                   // Capacity = 4
list.Add(2);                   // Capacity = 4
list.Add(3);                   // Capacity = 4
list.Add(4);                   // Capacity = 4
list.Add(5);                   // Capacity = 8 (agrandissement !)

Capacity vs. Count : c’est quoi la diff ?

• Count — le nombre d’éléments ajoutés dans la liste.
• Capacity — la taille du tableau interne qui stocke les éléments.

List<int> nums = new List<int>();
Console.WriteLine(nums.Count); // 0
Console.WriteLine(nums.Capacity); // En général 0 ou une petite valeur

nums.Add(123);
Console.WriteLine(nums.Count); // 1
Console.WriteLine(nums.Capacity); // Peut être plus grand que Count

nums.Capacity = 1000; // Tu peux augmenter Capacity à la main si tu sais que tu vas avoir plein d’éléments

La plupart des devs utilisent que Count, mais si tu fais des applis qui doivent être super rapides (genre des jeux ou de l’analyse de données), régler Capacity peut être utile.

5. Exemple

On continue à faire évoluer notre petite appli — maintenant, par exemple, l’utilisateur peut ajouter ses nombres préférés, puis bosser avec la liste : insérer, supprimer, afficher et vider.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> favoriteNumbers = new List<int>();

        Console.WriteLine("Tape tes nombres préférés (un par ligne, 0 pour finir) :");
        while (true)
        {
            int num = int.Parse(Console.ReadLine());
            if (num == 0) break;
            favoriteNumbers.Add(num);
        }

        Console.WriteLine("Tes nombres préférés :");
        foreach (int n in favoriteNumbers)
        {
            Console.Write(n + " ");
        }

        Console.WriteLine("\nTu veux supprimer le premier nombre ? (y/n)");
        if (Console.ReadLine().ToLower() == "y")
        {
            favoriteNumbers.RemoveAt(0);
        }

        Console.WriteLine("Voilà ta liste maintenant :");
        foreach (int n in favoriteNumbers)
        {
            Console.Write(n + " ");
        }
    }
}

Remarque : Ici on utilise int.Parse. Dans les vrais projets, il vaut mieux toujours vérifier la saisie avec int.TryParse, pour pas faire planter le programme à la moindre erreur de l’utilisateur.

6. Erreurs fréquentes et pièges des débutants

Un scénario super courant : tu fais une boucle de 0 à List.Count, mais pendant la boucle (genre dans un foreach) tu modifies la liste (tu ajoutes ou tu supprimes des éléments). Fais pas ça ! Les pros appellent ça "modifier une collection pendant qu’on la parcourt". Dans la plupart des cas, tu vas direct avoir une exception InvalidOperationException.

Exemple de mauvais code :

foreach (int n in numbers)
{
    if (n < 0)
        numbers.Remove(n); // BOUM ! Erreur à l’exécution.
}

La bonne façon : soit tu collectes d’abord les index/éléments à supprimer dans une autre liste, soit tu utilises une boucle for en partant de la fin.