En savoir plus sur les différences entre les tableaux, les listes et les ArrayLists

Certains points de connaissances peuvent être utilisés tout le temps, mais dans le développement réel, nous pouvons seulement les connaître et ne pas savoir pourquoi, donc des résumés réguliers seront d'une grande aide pour notre amélioration et notre progrès. L'article suivant vous présentera les différences entre les tableaux, les listes et les ArrayLists. J'espère qu'il vous sera utile.

La différence entre tableau, Liste et ArrayList

Les tableaux sont stockés en continu en mémoire , donc sa vitesse d'indexation est très rapide, et l'attribution et la modification d'éléments sont également très simples, comme :

string[] s=new string[3];
//赋值
 s[0]="a"; s[1]="b"; s[2]="c";
//修改
 s[1]="b1";

Cependant, les tableaux présentent également quelques défauts. Par exemple, il est très gênant d'insérer des données entre deux données dans un tableau. Lors de la déclaration d'un tableau, il faut également spécifier la longueur du tableau. Si la longueur du tableau est trop longue, cela entraînera un gaspillage de mémoire. Si la longueur du tableau est trop courte, cela entraînera une erreur de débordement de données. Cela devient très gênant si nous ne connaissons pas la longueur du tableau lors de sa déclaration. C# a d'abord fourni l'objet ArrayList pour surmonter ces lacunes.

ArrayList est une classe spéciale fournie par .Net Framework pour le stockage et la récupération de données. Elle fait partie de l'espace de noms System.Collections. Sa taille augmente et se contracte dynamiquement en fonction des données qui y sont stockées. Par conséquent, nous n'avons pas besoin de spécifier sa longueur lors de la déclaration de l'objet ArrayList. ArrayList hérite de l'interface IList, il peut donc facilement ajouter, insérer et supprimer des données :

ArrayList list = new ArrayList();
//新增数据
 list.Add("abc"); list.Add(123);
//修改数据
 list[2] = 345;
//移除数据
 list.RemoveAt(0);
//插入数据 
list.Insert(0, "hello world");

D'après l'exemple ci-dessus, ArrayList semble résoudre toutes les lacunes des tableaux, donc c'est parfait. La liste apparaît à nouveau après C# 2.0 ?

Dans la liste, nous avons non seulement inséré la chaîne "abc", mais également inséré le nombre 123. De cette manière, l'insertion de différents types de données dans ArrayList est autorisée. Parce qu'ArrayList traitera toutes les données qui y sont insérées comme un type d'objet. De cette façon, lorsque nous utilisons les données de l'ArrayList pour résoudre le problème, une erreur de non-concordance de type est susceptible d'être signalée, ce qui signifie que l'ArrayList n'est pas de type sécurisé. Même si nous veillons à être prudents lors de l'insertion des données et à insérer le même type de données, nous devons toujours les convertir dans les types d'origine correspondants pour les traiter lors de leur utilisation. Cela implique des opérations de boxing et unboxing, qui entraîneront d’importantes pertes de performances.

Le concept de boxing et unboxing : En termes simples : Boxing : Emballage de données de type valeur dans une instance d'un type référence, par exemple en attribuant la valeur 123 du type int à l'objet object o

int i=123; object o=(object)i;

unboxing : il s'agit d'extraire le type de valeur des données de référence. Par exemple, attribuer la valeur de l'objet object o à une variable de type int i

object o=123; int i=(int)o;

. et le déballage est très gourmand en performances.

C'est précisément parce qu'ArrayList présente les inconvénients des types non sécurisés et du boxing et unboxing que le concept de génériques est apparu après C# 2.0. La classe List est l'équivalent générique de la classe ArrayList. La plupart de son utilisation est similaire à ArrayList, car la classe List hérite également de l'interface IList. La différence la plus critique est que lors de la déclaration de la collection List, nous devons également déclarer le type d'objet des données dans la collection List. Par exemple :

List<int> list = new List<int>();
//新增数据
 list.Add(123);
//修改数据 
list[0] = 345;
//移除数据
list.RemoveAt(0);

Dans l'exemple ci-dessus, si nous insérons le caractère de chaîne "hello world" dans la collection List, l'EDI signalera une erreur et ne parviendra pas à compiler. Cela évite les problèmes de sécurité de type et les problèmes de performances liés au boxing et au unboxing mentionnés précédemment.

En même temps, List ne peut pas être construit, mais vous pouvez créer une référence à List comme ci-dessus, et ListArray peut être construit.

List list;     //正确   list=null; 
List list=new List();    //   是错误的用法

List list = new ArrayList(); Cette phrase crée un objet ArrayList et le retrace jusqu'à la liste. À l'heure actuelle, il s'agit d'un objet List. Certains ArrayList ont des propriétés et des méthodes que List n'a pas, il ne peut donc plus être utilisé. ArrayList list=new ArrayList(); crée un objet et conserve toutes les propriétés d'ArrayList.

Avantages des génériques List :

En vous permettant de spécifier les types spécifiques sur lesquels une classe ou une méthode générique opère, la fonctionnalité générique transfère la tâche de sécurité des types de vous au compilateur. Il n'est pas nécessaire d'écrire du code pour détecter si le type de données est correct, car le type de données correct est appliqué au moment de la compilation. Réduit le besoin de conversions de type et la possibilité d’erreurs d’exécution. Les génériques assurent la sécurité des types sans la surcharge de plusieurs implémentations.

Cet article provient de la rubrique Tutoriel C#.Net, bienvenue pour apprendre !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!