Jeu Vidéo 2

Listes

Qu'est-ce que c'est?

Une liste (List) est un objet de la catégorie des collections qui, tout comme un tableau, permet de de stocker plusieurs valeurs de même type dans une seule variable. Cependant, certaines caractéristiques des listes sont différentes des tableaux.

Caractéristiques

• Comme pour un tableau...
  • une liste ne peut contenir que des valeurs de même type: int, float, string, bool, GameObject, etc.
  • chaque valeur correspond à un indice (une position).
  • Les indices débutent toujours à 0. Ainsi, la première valeur d'une liste est à l'indice 0, la deuxième valeur est à l'indice 1, etc.
• Contrairement à un tableau...
  • une liste est de taille variable: On peut y ajouter des valeurs ou en supprimer à notre guise.
  • Les listes sont plus faciles à manipuler par programmation que les tableaux: Elles offrent de nombreuses méthodes (fonctions) en C#/Unity.
  • Les listes sont moins performantes que les tableaux: pour stocker et consulter de très grandes quantités d'items, on préfère utiliser des tableaux quand c'est possible.

---

Déclaration

Il y a 2 façons principales de déclarer une Liste.

// Façon 1: Déclaration sans initialisation
// Puisqu'une liste est de taille variable, on n'a pas à
// spécifier de longueur lors de la déclaration...
List<int> mesNombres = new List<int>(); // liste vide

// Façon 2: Déclaration avec initialisation directe
List<string> mesMots = new List<string>(){"pomme","poire","raisin"}; // liste de 3 items

Créer une liste avec les valeurs d'un tableau

// Un tableau...
int[] nombres = {2,7,8};

// Une liste, peuplée avec les valeurs de ce tableau
List<int> listeDeNombres = new List<int>(nombres);

---

Accéder à une valeur, avec liste[indice]

On peut accèder à une valeur si on connaît son indice. On peut consulter cette valeur (pour l'afficher par exemple), ou la modifier.

Ces accès se font de la même façon que pour un tableau.

// liste de 5 entiers pour cet exemple
List<int> mesNombres = new List<int>(){3,6,9,5,8}; // liste de 5 items

// Donc:
// 3 est à l'indice 0
// 6 est à l'indice 1
// 9 est à l'indice 2
// 5 est à l'indice 3
// 8 est à l'indice 4


// Afficher la valeur 9 à partir de cette liste:
Debug.Log( mesNombres[2] );

// Afficher la valeur 9 à partir de cette liste:
Debug.Log( mesNombres[2] );

// Remplacer la valeur 6 de cette liste par un 0:
mesNombres[1] = 0; // la liste vaut maintenant {3,0,9,5,8}

// Faire la somme des 2 dernières valeurs de la liste:
int total = mesNombres[3] + mesNombres[4];  // total vaut 13

// Augmenter de 10 la dernière valeur de la liste (pour qu'elle soit 18):
mesNombres[4] = mesNombres[4] + 10;
// on aurait pu faire à la place...
mesNombres[4] += 10;

---

La longueur d'une liste, avec liste.Count

Au besoin, on peut mesurer la longueur d'une liste par programmation grâce à la propriété Count:

List<int> mesNombres = new List<int>(){3,6,9,5,8};

int nb = mesNombres.Count;

Debug.Log( "Cette liste contient " + nb + " valeurs." ); // Affiche: Cette liste contient 5 valeurs.

Astuce: Afficher sous forme de chaine les valeurs (primitives) d'une liste

List<int> liste = new List<int>(){1,2,3};

string chaine = string.Join(",", liste);
Debug.Log(chaine); // Affiche 1,2,3	  

---

Quelques méthodes utilisées pour manipuler les listes

Voici une sélection des méthodes les plus populaires pour manipuler les valeurs dans une liste. Pour connaître l'ensemble des méthodes disponibles, consultez la documentation officielle: List en C# sur le site de Microsoft

Add()

Ajoute un item à la fin de la liste

listePrenoms.Add("Bob");

---

AddRange( )

Ajoute plusieurs items à la fin d'une liste (ces items sont souvent indiqués en tant que tableau).

string[ ] tableauAmis = { "Paul", "Julie", "Bill" }
listeAmis.AddRange(tableauAmis); // ajoute Paul, Julie et Bill à ma liste d'amis

---

Clear( )

Supprime tous les items d'une liste (efface toutes les valeurs).

nombres.Clear(); // nombres.Count vaut  0

---

Contains( )

Indique si l'item spécifié est présent ou non (true/false) dans une liste.

List<int> nombres=new List<int>(){1,2,3};
Debug.Log(nombres.Contains(2)); // Affiche true

---

IndexOf( )

Donne l'indice du premier item trouvé dans la liste qui correspond à l'item spécifié. Si l'item n'est pas trouvé dans la liste, IndexOf() retourne -1. Si une position est spécifiée en plus de l'item recherché, la recherche faite par IndexOf( ) se fera à partir de cette position au lieu de la position 0 (par défaut)

List<int> nombres=new List<int>(){5,7,6,8,6,2,6};

Debug.Log(nombres.IndexOf(6)); // Affiche 2
Debug.Log(nombres.IndexOf(6,3)); // Affiche 4
Debug.Log(nombres.IndexOf(9)); // Affiche -1

---

Insert( )

Insère un item à l'indice indiqué dans une liste.

List<string> noms = new List<string>( ){"Bob","Ève"};
noms.Insert(1,"Paul"); // noms vaut {"Bob","Paul","Ève"}

---

InsertRange( )

Insère plusieurs items à l'indice indiqué dans une liste (ces items sont souvent indiqués en tant que tableau).

List<int> nombres = new List<int>( ){4,5,6,7,8};
int[] valeurs = {1,2,3};
nombres.InsertRange(2, valeurs); // nombres vaut {4,5,1,2,3,6,7,8}

---

Remove( )

Supprime la première occurence d'un item spécifié dans une liste.

List<int> nombres = new List<int>( ){4,5,6,5,5};
nombres.Remove(5);// nombres vaut {4,6,5,5}

---

RemoveAt( )

Supprime l'item à l'indice indiqué.

List<int> nombres = new List<int>( ){4,5,6,5,5};
nombres.RemoveAt(3); // nombres vaut {4,5,6,5}

---

RemoveRange( )

Supprime n items à partir de l'indice indiqué.

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

// Efface 3 items à partir de l'indice 1
nombres.RemoveRange(1,3); // nombres vaut {6,2,1}

---

Reverse( )

Inverse l'ordre des items dans la liste.

List<int> nombres = new List<int>( ){2,5,7};
nombres.Reverse(); // nombres vaut {7,5,2}

---

Sort( )

Trie les items (types primitifs: int, float, bool, string, char, etc.) d'une Liste en ordre croissant (alphabétique ou numérique).

List<int> nombres = new List<int>( ){2,5,22,1,7};
nombres.Sort(); // nombres vaut {1,2,5,7,22}

---