HashSet vs Liste en C#

1. HashSet<T> en C#
2. List<T> en C#
3. HashSet<T> vs. List<T> en C#

Ce tutoriel abordera les différences et les similitudes entre un HashSet<T> et un List<T> en C#.

HashSet<T> en C#

La définition mathématique d’un ensemble est une collection non ordonnée d’objets distincts. La structure de données HashSet en C# suit également le même principe.

Un HashSet est une collection d’objets non répétitifs qui ne suivent aucune séquence spécifique. Un HashSet est généralement utilisé lorsque nous ne voulons pas de valeurs en double dans nos données.

Il s’agit d’une collection générique incluse dans l’espace de noms System.Collection.Generic.

Un avantage de HashSet est que nous pouvons appliquer toutes les opérations d’ensemble comme l’union, l’intersection et la différence d’ensemble. Un inconvénient notable de l’utilisation d’un HashSet est que nous ne pouvons pas le trier car il ne suit aucune séquence spécifique.

L’extrait de code suivant nous montre comment nous pouvons travailler avec des ensembles de hachage en C#.

HashSet<int> weirdNumbers = new HashSet<int>();
weirdNumbers.Add(10);
weirdNumbers.Add(13);
weirdNumbers.Add(17);
weirdNumbers.Add(78);
weirdNumbers.Add(13);

Console.WriteLine("HashSet before removal");
foreach (int val in weirdNumbers) {
  Console.WriteLine(val);
}
weirdNumbers.Remove(13);
Console.WriteLine("HashSet after removal");
foreach (int val in weirdNumbers) {
  Console.WriteLine(val);
}

Production:

HashSet before removal
10
13
17
78
HashSet after removal
10
17
78

Nous avons montré comment nous pouvions créer un jeu de hachage générique, y insérer des valeurs, les supprimer du jeu de hachage et les imprimer à l’intérieur du jeu de hachage dans l’exemple de code ci-dessus.

La fonction Add() à l’intérieur de la classe HashSet<T> est utilisée pour insérer une seule valeur dans le jeu de hachage. En plus de la fonction Add(), de nombreuses autres fonctions utiles sont fournies dans la classe HashSet<T>.

La fonction Remove(T val) supprime val de notre ensemble de hachage. Il prend la valeur comme paramètre d’entrée et la supprime de notre ensemble de hachage.

List<T> en C#

En C#, une liste est une collection d’objets fortement typés. Les éléments d’une liste sont accessibles via un index.

Un objet liste contient de nombreuses méthodes utiles pour trier, rechercher et modifier une liste. Il est inclus dans l’espace de noms System.Collection.Generic.

Un autre avantage des listes est qu’elles fournissent une vérification de type au moment de la compilation et n’effectuent pas de boxing/un-boxing car elles sont génériques. Une liste de type T peut être initialisée avec List<T>.

Les extraits de code suivants montrent comment nous pouvons travailler avec des listes en C#.

List<int> weirdNumbers = new List<int>();
weirdNumbers.Add(10);
weirdNumbers.Add(17);
weirdNumbers.Add(78);
weirdNumbers.Add(13);
foreach (int val in weirdNumbers) {
  Console.WriteLine(val);
}

Production:

10
17
78
13

Dans le code ci-dessus, nous avons initialisé la liste d’entiers weirdNumbers dans la première ligne, inséré des valeurs dans la liste avec la fonction Add() et utilisé une boucle foreach pour imprimer toutes les valeurs à l’intérieur de la liste.

La fonction Add() à l’intérieur de la classe List<T> est utilisée pour insérer des valeurs dans la liste. En plus de la fonction Add(), de nombreuses autres fonctions utiles sont fournies dans la classe List<T>.

La fonction AddRange() peut insérer un autre tableau ou une autre liste dans une liste existante. Il prend la liste ou le tableau comme paramètres d’entrée et ajoute les éléments de la liste ou du tableau à la fin de la liste primaire.

Nous pouvons également utiliser la fonction Insert() pour insérer une seule valeur à un index spécifié dans la liste. La fonction Insert() prend l’indice entier et la valeur de type T comme paramètres d’entrée.

Nous avons beaucoup parlé de l’ajout de nouveaux éléments à une liste. Voyons comment nous pouvons supprimer des éléments existants d’une liste.

La fonction Remove(T val) supprime la première occurrence du val à l’intérieur de notre liste. Il prend la valeur comme paramètre d’entrée et supprime la première occurrence de cette valeur dans notre liste à partir de l’index 0.

La fonction RemoveAt(int index) supprime la valeur à un index spécifique de notre liste. Il prend l’index comme paramètre d’entrée et supprime toute valeur placée.

L’extrait de code suivant met toutes les fonctions dont nous avons discuté dans un petit bloc soigné.

List<int> weirdNumbers = new List<int>();
weirdNumbers.Add(10);
weirdNumbers.Add(17);
weirdNumbers.Add(78);
weirdNumbers.Add(13);
weirdNumbers.Insert(3, 31);
Console.WriteLine("List before removal");
foreach (int val in weirdNumbers) {
  Console.WriteLine(val);
}
weirdNumbers.Remove(31);
weirdNumbers.RemoveAt(1);
Console.WriteLine("List after removal");
foreach (int val in weirdNumbers) {
  Console.WriteLine(val);
}

Production:

List before removal
10
17
78
31
13
List after removal
10
78
13

Nous avons montré comment créer une liste générique, y insérer des valeurs, supprimer des valeurs de la liste et imprimer les valeurs à l’intérieur de la liste dans l’exemple de code ci-dessus.

HashSet<T> vs. List<T> en C#

Les listes et les ensembles de hachage ont leurs avantages et leurs inconvénients les uns par rapport aux autres. Bien que les ensembles de hachage soient beaucoup plus rapides que les listes pour de grandes quantités de données, les listes offrent des capacités d’indexation.

Bien que nous puissions trier des listes, les ensembles de hachage offrent la possibilité d’effectuer des opérations d’ensemble.

En résumé, listes ou ensembles de hachage, le choix dépend entièrement de notre problème.