Guide : Liste de Tableaux C# vs Liste
En C#, une liste de Tableaux C# et une liste classique sont deux structures de données différentes. Chacune a ses propres cas d’utilisation et avantages.
1. Définition
Aspect | Liste de Tableaux | Liste |
---|---|---|
Structure | Une liste où chaque élément est un tableau (ex. List<int[]> ). | Une collection dynamique d’éléments simples ou complexes. |
Type des éléments | Les éléments sont des tableaux. | Les éléments sont des objets simples ou des classes. |
Usage | Gérer des collections où chaque élément est un groupe de données de taille fixe ou variable. | Gérer des collections homogènes d’éléments individuels. |
2. Déclaration
Liste de Tableaux
Une liste de tableaux combine les fonctionnalités d’une liste et celles d’un tableau.
Exemple : Liste de tableaux d’entiers
List<int[]> listeTableaux = new List<int[]>();
Liste
Une liste classique est une collection dynamique simple.
Exemple : Liste d’entiers
List<int> liste = new List<int>();
3. Initialisation
Liste de Tableaux
Chaque élément ajouté à une liste de tableaux est un tableau.
Exemple : Ajouter des tableaux à une liste
List<int[]> listeTableaux = new List<int[]>
{
new int[] { 1, 2, 3 },
new int[] { 4, 5 },
new int[] { 6, 7, 8, 9 }
};
Liste
Chaque élément ajouté à une liste est une valeur individuelle.
Exemple : Ajouter des éléments à une liste
List<int> liste = new List<int> { 1, 2, 3, 4, 5 };
4. Accès aux Éléments
Liste de Tableaux
Accédez aux éléments avec deux indices :
- L’index du tableau dans la liste.
- L’index de l’élément dans le tableau.
Exemple :
Console.WriteLine(listeTableaux[0][1]); // Accède au deuxième élément du premier tableau.
Liste
Accédez directement à l’élément avec son index.
Exemple :
Console.WriteLine(liste[1]); // Accède au deuxième élément.
5. Parcourir les Éléments
Liste de Tableaux
Vous devez parcourir chaque tableau, puis chaque élément à l’intérieur.
Exemple :
foreach (int[] tableau in listeTableaux)
{
foreach (int valeur in tableau)
{
Console.Write(valeur + " ");
}
Console.WriteLine();
}
Liste
Vous parcourez directement les éléments.
Exemple :
foreach (int valeur in liste)
{
Console.WriteLine(valeur);
}
6. Modification
Liste de Tableaux
Modifiez un tableau entier ou un élément spécifique dans un tableau.
Exemple :
listeTableaux[0][1] = 99; // Modifie le deuxième élément du premier tableau.
Liste
Modifiez directement un élément via son index.
Exemple :
liste[1] = 99; // Modifie le deuxième élément de la liste.
7. Tri
Liste de Tableaux
Vous pouvez trier la liste de tableaux par un critère, comme la longueur des tableaux ou une valeur spécifique.
Exemple : Trier par longueur des tableaux
listeTableaux.Sort((a, b) => a.Length.CompareTo(b.Length));
Liste
Vous pouvez trier directement les éléments avec Sort
.
Exemple :
liste.Sort();
8. Comparaison des Usages
Critère | Liste de Tableaux | Liste |
---|---|---|
Flexibilité | Permet de regrouper des données similaires en groupes (tableaux). | Idéal pour des collections simples et homogènes. |
Facilité d’accès | Nécessite deux indices pour accéder aux données. | Accès direct avec un seul index. |
Performance | Plus complexe, mais offre des structures groupées. | Plus rapide pour des opérations simples. |
Tri avancé | Possible avec des critères complexes (longueur, valeurs). | Limité à des tris simples sur les éléments. |
Structure | Idéal pour des données structurées par groupe. | Idéal pour des données individuelles homogènes. |
Exemple Pratique
Problème : Gestion d’un Système de Cours
- Chaque cours contient plusieurs étudiants (un tableau).
- Vous voulez gérer plusieurs cours dans un système dynamique (une liste).
Solution : Liste de Tableaux
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// Liste de tableaux d'étudiants
List<string[]> cours = new List<string[]>
{
new string[] { "Alice", "Bob", "Charlie" },
new string[] { "David", "Emma" },
new string[] { "Frank", "Grace", "Hannah", "Ivy" }
};
// Afficher les cours
Console.WriteLine("=== Liste des cours ===");
for (int i = 0; i < cours.Count; i++)
{
Console.WriteLine($"Cours {i + 1} : {string.Join(", ", cours[i])}");
}
// Trier les cours par nombre d'étudiants
cours.Sort((a, b) => a.Length.CompareTo(b.Length));
Console.WriteLine("\nCours triés par nombre d'étudiants :");
for (int i = 0; i < cours.Count; i++)
{
Console.WriteLine($"Cours {i + 1} : {string.Join(", ", cours[i])}");
}
}
}
Solution : Liste
Si chaque étudiant est une entrée individuelle, utilisez une liste simple.
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// Liste d'étudiants
List<string> etudiants = new List<string> { "Alice", "Bob", "Charlie", "David", "Emma" };
// Afficher les étudiants
Console.WriteLine("Liste des étudiants : " + string.Join(", ", etudiants));
// Ajouter un étudiant
etudiants.Add("Frank");
// Trier les étudiants
etudiants.Sort();
// Afficher les étudiants triés
Console.WriteLine("Étudiants triés : " + string.Join(", ", etudiants));
}
}
Quand Utiliser Quelle Structure ?
Scénario | Liste de Tableaux | Liste |
---|---|---|
Groupes de données (ex. étudiants par cours). | ✅ Parfait pour regrouper et manipuler des groupes distincts. | ❌ Pas idéal pour les données groupées. |
Collection simple (ex. liste d’étudiants). | ❌ Complexe et inutile pour ce scénario. | ✅ Idéal pour des collections homogènes. |
Tri ou recherche sur des groupes. | ✅ Plus adapté pour appliquer des critères complexes. | ❌ Limité aux éléments simples. |
Synthèse 😉
- Utilisez une liste de tableaux lorsque vous avez besoin de regrouper des ensembles de données similaires (ex. étudiants par classe).
- Utilisez une liste classique pour des collections homogènes d’éléments simples (ex. liste d’étudiants).
La structure que vous choisissez dépend de vos besoins en termes de structure des données, de flexibilité, et de complexité.
Guide : LINQ pour Manipuler des Listes en C#
LINQ (Language Integrated Query) est une fonctionnalité puissante en C# qui permet de manipuler et de requêter des collections, comme des listes, de manière concise et lisible. Elle offre des méthodes pour filtrer, trier, regrouper et transformer des données.
1. Configuration et Namespace
Pour utiliser LINQ, ajoutez le namespace suivant en haut de votre fichier :
using System.Linq;
2. Méthodes Principales de LINQ
Voici les principales méthodes LINQ pour manipuler des listes en C#.
Méthode | Description |
---|---|
Where | Filtre les éléments selon une condition. |
Select | Projette chaque élément dans une nouvelle forme. |
OrderBy | Trie les éléments en ordre croissant. |
OrderByDescending | Trie les éléments en ordre décroissant. |
GroupBy | Regroupe les éléments selon une clé. |
First / FirstOrDefault | Retourne le premier élément (ou une valeur par défaut). |
Last / LastOrDefault | Retourne le dernier élément (ou une valeur par défaut). |
Any | Vérifie si au moins un élément satisfait une condition. |
All | Vérifie si tous les éléments satisfont une condition. |
Count | Retourne le nombre d’éléments satisfaisant une condition. |
Sum , Min , Max , Average | Effectue des calculs sur des données numériques. |
3. Exemples Pratiques
3.1. Filtrer une Liste (Where
)
Problème : Filtrer les nombres pairs dans une liste.
List<int> nombres = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };
var nombresPairs = nombres.Where(n => n % 2 == 0).ToList();
Console.WriteLine(string.Join(", ", nombresPairs)); // Résultat : 2, 4, 6, 8
3.2. Transformer une Liste (Select
)
Problème : Multiplier chaque élément d’une liste par 2.
List<int> nombres = new List<int> { 1, 2, 3, 4, 5 };
var doubles = nombres.Select(n => n * 2).ToList();
Console.WriteLine(string.Join(", ", doubles)); // Résultat : 2, 4, 6, 8, 10
3.3. Trier une Liste (OrderBy
et OrderByDescending
)
Problème : Trier les éléments d’une liste en ordre croissant et décroissant.
List<int> nombres = new List<int> { 5, 2, 8, 1, 3 };
var croissant = nombres.OrderBy(n => n).ToList();
var decroissant = nombres.OrderByDescending(n => n).ToList();
Console.WriteLine(string.Join(", ", croissant)); // Résultat : 1, 2, 3, 5, 8
Console.WriteLine(string.Join(", ", decroissant)); // Résultat : 8, 5, 3, 2, 1
3.4. Regrouper les Éléments (GroupBy
)
Problème : Grouper les mots par leur première lettre.
List<string> mots = new List<string> { "Pomme", "Poire", "Banane", "Prune", "Cerise" };
var groupes = mots.GroupBy(m => m[0]);
foreach (var groupe in groupes)
{
Console.WriteLine($"Clé : {groupe.Key}");
foreach (var mot in groupe)
{
Console.WriteLine($" - {mot}");
}
}
Résultat :
Clé : P
- Pomme
- Poire
- Prune
Clé : B
- Banane
Clé : C
- Cerise
3.5. Obtenir un Élement Spécifique (First
, Last
, Single
)
- Problème : Obtenir le premier élément pair dans une liste.
List<int> nombres = new List<int> { 1, 2, 3, 4, 5 };
int premierPair = nombres.First(n => n % 2 == 0);
Console.WriteLine(premierPair); // Résultat : 2
- Problème : Obtenir le dernier élément de la liste.
int dernier = nombres.Last();
Console.WriteLine(dernier); // Résultat : 5
3.6. Vérifications (Any
, All
)
- Problème : Vérifier si la liste contient au moins un nombre impair.
List<int> nombres = new List<int> { 2, 4, 6, 8 };
bool contientImpair = nombres.Any(n => n % 2 != 0);
Console.WriteLine(contientImpair); // Résultat : False
- Problème : Vérifier si tous les nombres sont positifs.
bool tousPositifs = nombres.All(n => n > 0);
Console.WriteLine(tousPositifs); // Résultat : True
3.7. Calculs (Sum
, Min
, Max
, Average
)
Problème : Calculer la somme, le minimum, le maximum et la moyenne d’une liste.
List<int> nombres = new List<int> { 1, 2, 3, 4, 5 };
int somme = nombres.Sum();
int minimum = nombres.Min();
int maximum = nombres.Max();
double moyenne = nombres.Average();
Console.WriteLine($"Somme : {somme}, Min : {minimum}, Max : {maximum}, Moyenne : {moyenne}");
Résultat :
Somme : 15, Min : 1, Max : 5, Moyenne : 3
3.8. Combiner LINQ
Problème : Filtrer les nombres pairs, les multiplier par 2, puis les trier en ordre décroissant.
List<int> nombres = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };
var resultat = nombres
.Where(n => n % 2 == 0) // Filtrer les pairs
.Select(n => n * 2) // Multiplier par 2
.OrderByDescending(n => n) // Trier en ordre décroissant
.ToList();
Console.WriteLine(string.Join(", ", resultat)); // Résultat : 16, 12, 8, 4
4. Avantages de LINQ
- Lisibilité : Les requêtes sont concises et faciles à lire.
- Puissance : Offre des opérations complexes comme le filtrage, le tri et la transformation avec une syntaxe simple.
- Chaînage : Permet de combiner plusieurs opérations en une seule requête.
- Interopérabilité : Fonctionne sur différents types de collections (listes, tableaux, bases de données, etc.).
5. Exemple Complet
Voici un exemple combinant plusieurs fonctionnalités LINQ pour analyser une liste d’étudiants.
using System;
using System.Collections.Generic;
using System.Linq;
public class Etudiant
{
public string Nom { get; set; }
public int Age { get; set; }
public double Note { get; set; }
}
class Program
{
static void Main()
{
List<Etudiant> etudiants = new List<Etudiant>
{
new Etudiant { Nom = "Alice", Age = 20, Note = 15.5 },
new Etudiant { Nom = "Bob", Age = 22, Note = 12.3 },
new Etudiant { Nom = "Charlie", Age = 21, Note = 9.8 },
new Etudiant { Nom = "David", Age = 23, Note = 16.0 }
};
// Étudiants ayant une note supérieure à 10
var admissibles = etudiants.Where(e => e.Note > 10).ToList();
Console.WriteLine("Étudiants admissibles :");
admissibles.ForEach(e => Console.WriteLine($"{e.Nom} - {e.Note}"));
// Étudiant ayant la meilleure note
var meilleur = etudiants.OrderByDescending(e => e.Note).First();
Console.WriteLine($"\nMeilleur étudiant : {meilleur.Nom} - {meilleur.Note}");
// Moyenne des notes
double moyenne = etudiants.Average(e => e.Note);
Console.WriteLine($"\nMoyenne des notes : {moyenne}");
}
}
Conclusion
- LINQ est une puissante abstraction pour manipuler des listes de manière déclarative.
- Ses méthodes permettent d’effectuer des opérations complexes en peu de code.
- Apprenez à combiner plusieurs méthodes pour résoudre des problèmes plus complexes de manière efficace.