📋 B2.3 - Listes et Collections en C

📋 Objectifs du cours

À la fin de ce cours, vous serez capable de : - ✅ Comprendre la différence entre tableaux et listes - ✅ Manipuler les tableaux (arrays) en C# - ✅ Utiliser les listes (List) et leurs méthodes - ✅ Travailler avec les dictionnaires (Dictionary) - ✅ Choisir la bonne collection selon le contexte

---

📊 Introduction aux collections

📦

Qu'est-ce qu'une collection ?

Une collection est une structure de données qui permet de stocker et organiser plusieurs éléments du même type ou de types différents. En C#, nous avons plusieurs types de collections adaptées à différents besoins.

🔍 Comparaison des principales collections

| Collection | Taille | Accès | Utilisation | |------------|--------|-------|-------------| | **Array** | Fixe | Index | Données de taille connue | | **List** | Variable | Index | Données dynamiques | | **Dictionary** | Variable | Clé | Associations clé-valeur |

---

🗂️ Les tableaux (Arrays)

📝 Déclaration et initialisation

// Déclaration avec taille fixe
int[] nombres = new int[5]; // Tableau de 5 entiers (0 par défaut)

// Déclaration avec initialisation
int[] scores = { 85, 92, 78, 96, 88 };

// Autre syntaxe d'initialisation
string[] noms = new string[] { "Alice", "Bob", "Charlie" };

// Initialisation avec new (C# 3.0+)
var couleurs = new[] { "Rouge", "Vert", "Bleu" };

🎯 Accès et modification

int[] notes = { 15, 18, 12, 16, 14 };

// Accès en lecture
Console.WriteLine($"Première note : {notes[0]}"); // 15
Console.WriteLine($"Dernière note : {notes[notes.Length - 1]}"); // 14

// Modification
notes[2] = 20; // Change 12 en 20

// Parcours avec for
for (int i = 0; i < notes.Length; i++)
{
    Console.WriteLine($"Note {i + 1} : {notes[i]}");
}

// Parcours avec foreach
foreach (int note in notes)
{
    Console.WriteLine($"Note : {note}");
}

🔧 Méthodes utiles pour les tableaux

int[] nombres = { 5, 2, 8, 1, 9, 3 };

// Taille du tableau
Console.WriteLine($"Taille : {nombres.Length}");

// Tri
Array.Sort(nombres);
Console.WriteLine("Trié : " + string.Join(", ", nombres)); // 1, 2, 3, 5, 8, 9

// Recherche
int index = Array.IndexOf(nombres, 5);
Console.WriteLine($"Index de 5 : {index}"); // 3

// Inversion
Array.Reverse(nombres);
Console.WriteLine("Inversé : " + string.Join(", ", nombres)); // 9, 8, 5, 3, 2, 1

// Copie
int[] copie = new int[nombres.Length];
Array.Copy(nombres, copie, nombres.Length);

---

📋 Les listes (List)

📈

Avantages des listes

Les listes sont des collections dynamiques qui peuvent grandir ou rétrécir pendant l'exécution. Elles offrent plus de flexibilité que les tableaux et de nombreuses méthodes utiles.

🚀 Création et initialisation

// Import nécessaire
using System.Collections.Generic;

// Liste vide
List<int> nombres = new List<int>();

// Liste avec capacité initiale
List<string> noms = new List<string>(10);

// Liste avec initialisation
List<double> prix = new List<double> { 19.99, 25.50, 12.75 };

// Syntaxe moderne (C# 9.0+)
List<string> couleurs = new() { "Rouge", "Vert", "Bleu" };

➕ Ajout d'éléments

List<string> fruits = new List<string>();

// Ajouter un élément à la fin
fruits.Add("Pomme");
fruits.Add("Banane");

// Ajouter plusieurs éléments
fruits.AddRange(new[] { "Orange", "Kiwi", "Mangue" });

// Insérer à une position spécifique
fruits.Insert(1, "Poire"); // Insère "Poire" à l'index 1

// Résultat : ["Pomme", "Poire", "Banane", "Orange", "Kiwi", "Mangue"]
Console.WriteLine(string.Join(", ", fruits));

🗑️ Suppression d'éléments

List<int> nombres = new List<int> { 1, 2, 3, 4, 5, 3, 6 };

// Supprimer la première occurrence
nombres.Remove(3); // Supprime le premier 3
// Résultat : [1, 2, 4, 5, 3, 6]

// Supprimer à un index spécifique
nombres.RemoveAt(0); // Supprime l'élément à l'index 0
// Résultat : [2, 4, 5, 3, 6]

// Supprimer une plage
nombres.RemoveRange(1, 2); // Supprime 2 éléments à partir de l'index 1
// Résultat : [2, 3, 6]

// Supprimer tous les éléments qui correspondent à une condition
nombres.RemoveAll(x => x > 3); // Supprime tous les nombres > 3
// Résultat : [2, 3]

// Vider la liste
nombres.Clear();

🔍 Recherche et vérification

List<string> animaux = new List<string> { "Chat", "Chien", "Oiseau", "Poisson" };

// Vérifier si un élément existe
bool aChat = animaux.Contains("Chat"); // true

// Trouver l'index d'un élément
int index = animaux.IndexOf("Chien"); // 1

// Trouver le dernier index
animaux.Add("Chat"); // Ajoute un deuxième "Chat"
int dernierIndex = animaux.LastIndexOf("Chat"); // 4

// Compter les éléments
int total = animaux.Count; // 5

// Vérifier si la liste est vide
bool estVide = animaux.Count == 0; // false

// Recherche avec condition (LINQ)
using System.Linq;
string premierOiseau = animaux.FirstOrDefault(a => a.StartsWith("O")); // "Oiseau"

🔄 Tri et manipulation

List<int> scores = new List<int> { 85, 92, 78, 96, 88 };

// Tri croissant
scores.Sort();
Console.WriteLine(string.Join(", ", scores)); // 78, 85, 88, 92, 96

// Tri décroissant
scores.Sort((a, b) => b.CompareTo(a));
Console.WriteLine(string.Join(", ", scores)); // 96, 92, 88, 85, 78

// Inversion
scores.Reverse();

// Conversion en tableau
int[] tableau = scores.ToArray();

// Copie vers une autre liste
List<int> copie = new List<int>(scores);

---

🗝️ Les dictionnaires (Dictionary)

🔑

Principe des dictionnaires

Un dictionnaire stocke des paires clé-valeur. Chaque clé est unique et permet d'accéder rapidement à sa valeur associée. C'est idéal pour créer des associations ou des index.

🏗️ Création et initialisation

// Import nécessaire
using System.Collections.Generic;

// Dictionnaire vide
Dictionary<string, int> ages = new Dictionary<string, int>();

// Dictionnaire avec initialisation
Dictionary<string, string> capitales = new Dictionary<string, string>
{
    { "France", "Paris" },
    { "Espagne", "Madrid" },
    { "Italie", "Rome" }
};

// Syntaxe moderne (C# 6.0+)
var notes = new Dictionary<string, double>
{
    ["Alice"] = 15.5,
    ["Bob"] = 18.0,
    ["Charlie"] = 12.5
};

➕ Ajout et modification

Dictionary<string, int> stock = new Dictionary<string, int>();

// Ajouter des éléments
stock.Add("Pommes", 50);
stock.Add("Bananes", 30);

// Syntaxe avec indexeur (plus simple)
stock["Oranges"] = 25;
stock["Kiwis"] = 15;

// Modifier une valeur existante
stock["Pommes"] = 45; // Change 50 en 45

// Ajouter seulement si la clé n'existe pas
if (!stock.ContainsKey("Mangues"))
{
    stock["Mangues"] = 20;
}

// Méthode TryAdd (C# 7.0+)
stock.TryAdd("Ananas", 10); // Ajoute seulement si la clé n'existe pas

🔍 Accès et recherche

Dictionary<string, double> prix = new Dictionary<string, double>
{
    ["Pain"] = 1.20,
    ["Lait"] = 0.95,
    ["Œufs"] = 2.50
};

// Accès direct (attention aux exceptions !)
double prixPain = prix["Pain"]; // 1.20

// Accès sécurisé avec TryGetValue
if (prix.TryGetValue("Beurre", out double prixBeurre))
{
    Console.WriteLine($"Prix du beurre : {prixBeurre}€");
}
else
{
    Console.WriteLine("Beurre non trouvé");
}

// Vérifier l'existence d'une clé
bool aPain = prix.ContainsKey("Pain"); // true

// Vérifier l'existence d'une valeur
bool aArticleA2Euros = prix.ContainsValue(2.00); // false

// Nombre d'éléments
int nombreArticles = prix.Count; // 3

🔄 Parcours des dictionnaires

Dictionary<string, int> scores = new Dictionary<string, int>
{
    ["Alice"] = 95,
    ["Bob"] = 87,
    ["Charlie"] = 92
};

// Parcours des paires clé-valeur
foreach (KeyValuePair<string, int> kvp in scores)
{
    Console.WriteLine($"{kvp.Key} : {kvp.Value} points");
}

// Syntaxe simplifiée (C# 7.0+)
foreach (var (nom, score) in scores)
{
    Console.WriteLine($"{nom} : {score} points");
}

// Parcours des clés seulement
foreach (string nom in scores.Keys)
{
    Console.WriteLine($"Joueur : {nom}");
}

// Parcours des valeurs seulement
foreach (int score in scores.Values)
{
    Console.WriteLine($"Score : {score}");
}

---

🎯 Exercices pratiques

🏋️ Exercice 1 : Gestionnaire de notes

Créez un programme qui : 1. Stocke les notes d'étudiants dans un dictionnaire 2. Permet d'ajouter, modifier et supprimer des notes 3. Calcule et affiche la moyenne de la classe 4. Trouve l'étudiant avec la meilleure note

// Votre code ici

🏋️ Exercice 2 : Inventaire de magasin

Créez un système d'inventaire qui : 1. Utilise un dictionnaire pour stocker les produits et leurs quantités 2. Permet d'ajouter/retirer du stock 3. Affiche les produits en rupture de stock (quantité = 0) 4. Calcule la valeur totale du stock (avec un dictionnaire des prix)

// Votre code ici

🏋️ Exercice 3 : Analyseur de texte

Créez un programme qui : 1. Lit un texte saisi par l'utilisateur 2. Compte le nombre d'occurrences de chaque mot 3. Affiche les mots par ordre de fréquence 4. Ignore la casse et la ponctuation

// Indice : utilisez string.Split() et char.IsPunctuation()

🏋️ Exercice 4 : Carnet d'adresses

Créez un carnet d'adresses qui : 1. Stocke nom, téléphone et email dans une classe Contact 2. Utilise une List pour stocker tous les contacts 3. Permet de rechercher par nom 4. Trie les contacts par ordre alphabétique

public class Contact
{
    public string Nom { get; set; }
    public string Telephone { get; set; }
    public string Email { get; set; }
}

---

⚡ Performances et bonnes pratiques

🚀

Conseils d'optimisation

**1. Choisir la bonne collection :**

// ✅ Pour des données de taille fixe
int[] scores = new int[10];

// ✅ Pour des données dynamiques avec accès par index
List<string> noms = new List<string>();

// ✅ Pour des associations clé-valeur
Dictionary<string, int> ages = new Dictionary<string, int>();

**2. Initialiser avec la bonne capacité :**

// ✅ Si vous connaissez la taille approximative
List<int> nombres = new List<int>(1000); // Évite les redimensionnements

**3. Utiliser les bonnes méthodes :**

// ❌ Lent pour de grandes collections
for (int i = 0; i < liste.Count; i++)
{
    if (liste[i] == valeur) return i;
}

// ✅ Plus rapide
int index = liste.IndexOf(valeur);

**4. Attention aux modifications pendant l'itération :**

// ❌ Erreur à l'exécution
foreach (var item in liste)
{
    if (condition)
        liste.Remove(item); // Exception !
}

// ✅ Solution
for (int i = liste.Count - 1; i >= 0; i--)
{
    if (condition)
        liste.RemoveAt(i);
}

---

📚 Points clés à retenir

🎯 Résumé du chapitre :

• Tableaux : Taille fixe, accès rapide par index
• Listes : Taille variable, nombreuses méthodes utiles
• Dictionnaires : Associations clé-valeur, accès rapide par clé
• Choix : Dépend du type de données et des opérations nécessaires
• Performance : Initialiser avec la bonne capacité, choisir les bonnes méthodes

---

🔗 Liens utiles

• Collections en C#
• List Class
• Dictionary Class

---

Étape précédente : B2.2 - Structures de contrôle
Prochaine étape : B2.4 - Fonctions et méthodes