1. Tableaux et listes en C# ; késako ?
Les tableaux et les listes sont deux types de structures de données couramment utilisées en C# et dans de nombreux autres langages de programmation. Ils permettent de stocker plusieurs valeurs dans une seule variable, ce qui est très utile pour organiser et manipuler des données.
Les tableaux en C#
Un tableau en C# est une collection ordonnée d’éléments du même type. Il a une taille fixe, ce qui signifie que tu ne peux pas ajouter ou supprimer des éléments après sa création. Chaque élément dans un tableau a un indice (ou un index), qui est un nombre entier commençant par 0 pour le premier élément, 1 pour le deuxième, et ainsi de suite. Tu peux accéder à n’importe quel élément du tableau à tout moment en utilisant son indice.
Par exemple, tu peux créer un tableau d’entiers de taille 5 comme suit :
int[] monTableau = new int[5];
Les listes en C#
Contrairement aux tableaux, les listes en C# sont dynamiques. Une liste est une collection ordonnée d’éléments qui peuvent être de n’importe quel type. La taille d’une liste peut changer pendant l’exécution du programme, ce qui signifie que tu peux ajouter ou supprimer des éléments.
Comme pour le tableau, chaque élément d’une liste a un indice. Des méthodes sont fournies pour ajouter, insérer, supprimer et trouver des éléments dans une liste.
Par exemple, tu peux créer une liste d’entiers comme suit :
List<int> maListe = new List<int>();
Les tableaux et les listes ont chacun leur propre utilité et peuvent être choisis en fonction des besoins spécifiques de ton programme. Ils offrent une grande flexibilité pour stocker et manipuler des données dans tes applications C#.
2. Déclarer un tableau en C#
La déclaration d’un tableau en C# suit une syntaxe précise. Un tableau doit être déclaré avec un type de données spécifique, et la taille du tableau (c’est-à-dire le nombre d’éléments qu’il peut contenir) doit également être indiquée au moment de la déclaration.
type[] nomDuTableau = new type[taille];
Dans cette syntaxe, type fait référence au type de données que le tableau va stocker. Ce peut être n’importe quel type valide en C#, comme int, string, double, etc. nomDuTableau est le nom que tu donnes à ton tableau, et [taille] représente le nombre d’éléments que le tableau peut contenir.
Par exemple, pour déclarer un tableau qui peut stocker 5 entiers, tu écris :
int[] monTableau = new int[5];
Dans cet exemple, int est le type de données, monTableau est le nom du tableau, et 5 est la taille du tableau. Ce tableau peut contenir 5 entiers.
Note qu’au moment de la déclaration, tous les éléments du tableau sont initialisés à la valeur par défaut pour le type de données. Pour int, par exemple, la valeur par défaut est 0. Ainsi, après la déclaration ci-dessus, monTableau contient {0, 0, 0, 0, 0}.
Rappelle-toi que la taille du tableau est fixe en C#. Une fois qu’un tableau est déclaré, tu ne peux pas en changer la taille.
3. Initialiser un tableau en C#
Une fois qu’un tableau est déclaré en C#, il est possible de l’initialiser, c’est-à-dire de lui attribuer des valeurs spécifiques. Il existe plusieurs façons de le faire, en voici quelques-unes.
Initialisation au moment de la déclaration
La façon la plus courante d’initialiser un tableau est de le faire au moment de la déclaration. Cela signifie que tu déclares le tableau et lui attribue des valeurs en une seule instruction.
int[] monTableau = new int[] {1, 2, 3, 4, 5};
Dans cet exemple, le tableau monTableau est déclaré et initialisé avec les valeurs 1, 2, 3, 4 et 5. Le tableau a une taille de 5, qui est déterminée par le nombre d’éléments que tu as fourni entre les accolades {}.
Note que tu peux omettre la taille du tableau dans cette déclaration, car le compilateur C# peut déduire la taille du tableau en fonction du nombre d’éléments que tu as fournis.
Initialisation après la déclaration
Si tu as déjà déclaré un tableau, tu peux également l’initialiser en attribuant des valeurs à chaque index du tableau.
int[] monTableau = new int[5]; // Déclaration
monTableau[0] = 1; // Initialisation
monTableau[1] = 2;
monTableau[2] = 3;
monTableau[3] = 4;
monTableau[4] = 5;
Dans cet exemple, monTableau est d’abord déclaré avec une taille de 5. Ensuite, chaque élément du tableau est initialisé en utilisant son index. Rappelle-toi que les indices de tableau en C# commencent à 0 pour le premier élément.
Ces deux méthodes te permettent de travailler avec des tableaux en C#, en fonction de tes besoins et de tes préférences.
4. Accéder aux éléments d’un tableau en C#
Une fois qu’un tableau a été initialisé avec des valeurs, l’accès à ces valeurs est une tâche courante. Cela permet de lire, modifier et manipuler les données stockées dans le tableau.
On utilise d’index d’un élément pour y accéder. Les indices de tableau en C# commencent à 0 et augmentent de 1 pour chaque élément suivant.
Voici comment accéder à un élément d’un tableau en utilisant son index :
int[] monTableau = new int[] {1, 2, 3, 4, 5};
int premierElement = monTableau[0]; // accéder au premier élément
int troisiemeElement = monTableau[2]; // accéder au troisième élément
Dans cet exemple, le tableau monTableau est déclaré et initialisé avec les valeurs 1, 2, 3, 4 et 5. Ensuite, les éléments sont accessibles en utilisant leurs indices.
Modifier un élément d’un tableau
Tu peux modifier un élément d’un tableau en utilisant son index. Par exemple, si tu veux changer la valeur du premier élément de monTableau à 10, tu peux faire :
monTableau[0] = 10; // modifier le premier élément
Après cette instruction, le tableau monTableau contient les valeurs {10, 2, 3, 4, 5}.
Parcourir un tableau avec une boucle
Pour accéder à tous les éléments d’un tableau, tu peux utiliser une boucle. La boucle for peut être utilisée pour parcourir le tableau dans son intégralité :
for (int i = 0; i < monTableau.Length; i++)
{
Console.WriteLine(monTableau[i]); // imprime chaque élément du tableau
}
Dans cet exemple, monTableau.Length donne la taille du tableau, et monTableau[i] accède à chaque élément du tableau en utilisant l’index i.
5. Déclarer une liste en C#
Une liste en C# est une structure de données dynamique, ce qui signifie qu’elle peut changer de taille pendant l’exécution du programme. Contrairement aux tableaux, qui ont une taille fixe, les listes peuvent grandir et rétrécir en fonction de vos besoins.
Une liste est une collection ordonnée d’éléments. Chaque élément a un index, et tu peux ajouter, insérer, supprimer et trouver des éléments à n’importe quel endroit dans la liste.
Pour utiliser les listes en C#, tu dois inclure le namespace System.Collections.Generic en haut de ton fichier :
using System.Collections.Generic;
Déclaration d’une liste
La déclaration d’une liste en C# est similaire à celle d’un tableau, mais elle utilise la classe List<T>, où T est le type de données que la liste va stocker.
List<int> maListe = new List<int>();
Dans cet exemple, <int> est le type de la liste, maListe est le nom de la liste, et new List<int>() est l’instance de la liste.
Contrairement à un tableau, tu n’as pas besoin de spécifier une taille lors de la déclaration d’une liste. Cela est dû au fait que les listes sont dynamiques et peuvent changer de taille. Par défaut, une liste nouvellement créée ne contient aucun élément.
Tu peux également déclarer et initialiser une liste en même temps, tout comme un tableau :
List<int> maListe = new List<int> {1, 2, 3, 4, 5};
Dans cet exemple, la liste maListe est déclarée et initialisée avec les valeurs 1, 2, 3, 4 et 5.
6. Ajouter des éléments à une liste en C#
Ajouter des éléments à une liste en C# est une opération courante qui peut être effectuée de différentes manières. La classe List<T> fournit plusieurs méthodes pour ajouter des éléments à une liste.
Ajouter un élément à la fin de la liste
La méthode Add() est utilisée pour ajouter un élément à la fin de la liste. Voici comment tu peux l’utiliser :
List<int> maListe = new List<int>(); // créer une nouvelle liste vide
maListe.Add(1); // ajouter 1 à la liste
maListe.Add(2); // ajouter 2 à la liste
Après ces instructions, maListe contient les valeurs {1, 2}.
Ajouter plusieurs éléments à la fin de la liste
Si tu as plusieurs éléments à ajouter à une liste, tu peux utiliser la méthode AddRange(). Cette méthode prend une collection d’éléments et les ajoute à la fin de la liste.
List<int> maListe = new List<int>(); // créer une nouvelle liste vide
maListe.AddRange(new int[] {1, 2, 3, 4, 5}); // ajouter plusieurs éléments à la liste
Après cette instruction, maListe contient les valeurs {1, 2, 3, 4, 5}.
Insérer un élément à une position spécifique
Parfois, tu voudras peut-être insérer un élément à une position spécifique de la liste, plutôt qu’à la fin. Pour cela, tu peux utiliser la méthode Insert(). Cette méthode prend deux paramètres : l’index à laquelle l’élément doit être inséré et l’élément à insérer :
List<int> maListe = new List<int>() {1, 2, 3, 4, 5}; // créer et initialiser une liste
maListe.Insert(2, 10); // insérer 10 à l’index 2
Après cette instruction, maListe contient les valeurs {1, 2, 10, 3, 4, 5}. Note que l’élément à l’index 2 est maintenant 10, et tous les éléments suivants ont été décalés vers la droite.
Ces méthodes te donnent une grande flexibilité pour ajouter des éléments à une liste en C#, selon tes besoins.