C-SHARP - 4.3 Listes

Cette vidéo aborde une notion essentielle en C# : les listes (List<T>). Une liste ressemble à un tableau mais offre beaucoup plus de flexibilité : sa taille n'est pas fixe, on peut ajouter ou retirer des éléments à volonté.

Déclarer une liste

Deux écritures possibles. La syntaxe explicite : List<string> ma_liste = new List<string>();. La syntaxe avec var pour la lisibilité : var ma_liste = new List<string>();. Contrairement aux tableaux, on n'a pas besoin de spécifier de taille à la création.

Les méthodes essentielles

• Add(element) : ajoute un élément en fin de liste.
• Count : équivalent de Length pour les tableaux, renvoie le nombre d'éléments.
• Remove(valeur) : supprime la première occurrence correspondant à la valeur.
• RemoveAt(index) : supprime l'élément à l'index donné.
• Accès indexé : liste[0] pour lire ou modifier une case précise.

var liste = new List<string>();
liste.Add("Bonjour");
liste.Add("Hello");
liste[1] = "Salut";          // modifier
liste.Remove("Bonjour");     // supprimer par valeur
liste.RemoveAt(0);           // supprimer par index

for (int i = 0; i < liste.Count; i++)
{
    Console.WriteLine(liste[i]);
}

Exercice : équipe de foot

Construisons un programme qui demande à l'utilisateur de saisir les joueurs de son équipe, sans connaître à l'avance leur nombre. Astuce : une boucle while(true) qui s'interrompt sur une chaîne vide via un break :

var liste_joueurs = new List<string>();
while (true)
{
    Console.WriteLine("Entrer le nom d'un joueur (Sinon taper entrer pour terminer) :");
    string joueur = Console.ReadLine();
    if (joueur == "") break;
    liste_joueurs.Add(joueur);
}

for (int i = 0; i < liste_joueurs.Count; i++)
{
    Console.WriteLine(liste_joueurs[i]);
}

Le programme s'adapte à n'importe quelle taille d'équipe. Tant que l'utilisateur saisit un nom, on l'ajoute. S'il appuie sur Entrée à vide, la condition du if est satisfaite et le break sort de la boucle. Cette combinaison liste + boucle infinie contrôlée est un pattern extrêmement courant. Les listes offrent énormément d'autres méthodes que nous découvrirons dans de futures vidéos.

En résumé

Une liste en C# permet de stocker plusieurs éléments sans fixer la taille à l'avance, contrairement aux tableaux. On déclare une liste avec `List<type>` ou `var`, puis on ajoute des éléments via la méthode `Add()`, on les modifie par index, et on les supprime avec `Remove()` ou `RemoveAt()`. Les listes sont parcourues en boucle for avec la propriété `Count` pour obtenir le nombre d'éléments.

Points clés

• Une liste est similaire au tableau mais sa taille est dynamique et non fixée
• Déclaration : `List<type> nom = new List<type>();` ou initialisée avec des accolades et des valeurs
• Méthode `Add()` pour ajouter des éléments à la liste sans limite
• Propriété `Count` pour obtenir le nombre total d'éléments dans la liste
• Méthode `Remove(valeur)` supprime la première occurrence; `RemoveAt(index)` supprime par position
• Accès par index avec crochets : `liste[0]` pour le premier élément, comme les tableaux

Questions fréquentes

Quelle est la différence principale entre une liste et un tableau en C# ?

Une liste a une taille dynamique et peut accueillir autant d'éléments qu'on souhaite ajouter, tandis qu'un tableau a une taille fixée à sa création. Les listes offrent plus de flexibilité avec des méthodes comme Add() et Remove().

Comment ajouter et supprimer des éléments d'une liste ?

Pour ajouter : `maListe.Add(valeur);`. Pour supprimer la première occurrence d'une valeur : `maListe.Remove(valeur);`. Pour supprimer par index : `maListe.RemoveAt(index);`.

Comment parcourir tous les éléments d'une liste en C# ?

Utilisez une boucle for classique : `for (int i = 0; i < maListe.Count; i++) { Console.WriteLine(maListe[i]); }`. La propriété `Count` retourne le nombre total d'éléments.