La classe System.Collections.ArrayList est un tableau spécial. En ajoutant et en supprimant les éléments, la longueur du tableau peut être modifiée dynamiquement.
un. avantage
1. prend en charge la fonction de changement de taille automatique
2. Insertion flexible des éléments
3. Suppression flexible des éléments
deux. limitation
Comparé aux tableaux ordinaires, la vitesse est légèrement pire
trois. Ajouter des éléments
1. PublicVirtualIntadd (objectValue);
Ajouter un objet à la fin de ArrayList
ArrayList Alist = new ArrayList (); Alist.add ("A"); Alist.add ("B"); Alist.Add ("C"); Alist.Add ("D"); Alist.Add ("E");Le contenu est
abcde
2. PublicVirtualVoidInsert (inindex, objectValue);
Insérer un élément dans l'index spécifié de ArrayList
ArrayList Alist = new ArrayList (); Alist.add ("A"); Alist.Add ("B"); Alist.Add ("C"); Alist.Add ("D"); Alist.Add ("E"); Alist.Insert (0, "AA");Le résultat est
aaabcde
3. publicVirtualVoiDinserTrange (inindex, icollectionc);
Insérez un élément de la collection dans l'index spécifié de la liste Array
ArrayList Alist = new ArrayList (); Alist.Add ("A"); Alist.Add ("B"); Alist.Add ("C"); Alist.Add ("D"); Alist.Add ("E"); ArrayList List2 = NewArrayList (); List2.Add ("TT"); List2.Add ("TTT"); Alist.Le résultat est
abttttcde
Quatre. supprimer
1. PublicVirtualVoidRemove (objectObj);
Supprimez la première correspondance d'un objet spécifique d'un ArrayList, notez qu'il s'agit du premier
ArrayList Alist = new ArrayList (); Alist.Add ("A"); Alist.Add ("B"); Alist.Add ("C"); Alist.Add ("D"); Alist.Add ("E"); Alist.Remove ("A");Le résultat est
bcde
2. PublicVirtualVoidReMoveat (inindex);
Supprime les éléments à l'indice spécifié de ArrayList
Alist.Add ("A"); Alist.add ("B"); Alist.Add ("C"); Alist.Add ("D"); Alist.Add ("E"); Alist.Removeat (0);Le résultat est
bcde
3. PublicVirtualVoidReMoverange (inindex, intCount);
Supprime une gamme d'éléments de la liste Array. L'indice représente l'index, le nombre représente le nombre à partir de l'index
Alist.Add ("A"); Alist.add ("B"); Alist.Add ("C"); Alist.Add ("D"); Alist.Add ("E"); Alist.reMoverange (1,3);Le résultat est
Copiez le code comme suit: AE
4. publicVirtualVoidClear ();
Supprimez tous les éléments de ArrayList.
cinq. Trier
1.PublicVirtualVoidsort ();
Trier les éléments dans une liste d'array ou une partie de celui-ci.
ArrayListalist = newArrayList (); Alist.add ("E"); Alist.Add ("A"); Alist.Add ("B"); Alist.Add ("C"); Alist.Add ("D"); DropdownList1.Datasource = Alist; // DropdownListDrodList1; DropdownList1.Databind (););Le résultat est
EABCD
ArrayListalist = newArrayList (); Alist.add ("A"); Alist.Add ("B"); Alist.Add ("C"); Alist.Add ("D"); Alist.Add ("E"); Alist.Sort (); // Triting DropdownList1.DataSource = Alist; // DropdownListDroPdropdlist1;Le résultat est
abcde
2.PublicVirtualVoiDeverse ();
Inverse l'ordre des éléments dans une liste de listes ou une partie de celui-ci.
ArrayListalist = NewArrayList (); Alist.add ("A"); Alist.Add ("B"); Alist.Add ("C"); Alist.Add ("D"); Alist.Add ("E"); Alist.Reverse (); // Renverse DropdownList1.DataSource = Alist; // DropdownListDroPdroplistlist1; Dropdownlist1.databind ();Le résultat est
EDCBA
six. Trouver
1.PublicVirtualIntIndexof (objet);
2.PublicVirtualIntIndexof (objet, int);
3.PublicVirtualIntIndexof (objet, int, int);
Renvoie l'indice basé sur le zéro de la première correspondance d'un ArrayList ou d'une partie de celui-ci. Aucun retour -1 n'a été trouvé.
ArrayList Alist = new ArrayList (); Alist.add ("A"); Alist.add ("B"); Alist.add ("C"); Alist.add ("D"); Alist.add ("E"); intNindex = Alist.indexof ("a"); // 1 nindex = Alist.indexof ("p"); // non trouvé, -1 4.PublicVirtualIntLastIndexof (objet);
5.PublicVirtualIntLastIndexof (objet, int);
6.PublicVirtualIntLastIndexof (objet, int, int);
Renvoie l'indice basé sur le zéro de la dernière correspondance d'un ArrayList ou d'une partie de celui-ci.
ArrayList Alist = new ArrayList (); Alist.add ("A"); Alist.add ("B"); Alist.add ("A"); // Identique à 0 Alist.Add ("D"); Alist.add ("E"); intNindex = Alist.LastIndexof ("a"); // La valeur est 2 au lieu de 0 7.PublicVirtualBoolContains (objectitem);
Détermine si un élément est dans une liste Array. Retour True si vous êtes inclus, sinon retourne false
Sept. autre
1. publicVirtualIntCapacity {get; set;}
Obtient ou définit le nombre d'éléments qu'un ArrayList peut contenir.
2. PublicVirtualIntCount {get;}
Obtient le nombre d'éléments contenus dans la liste Array.
La capacité est le nombre d'éléments qu'un ArrayList peut stocker. Le nombre est le nombre d'éléments réellement contenus dans la liste Array. La capacité est toujours supérieure ou égale au nombre. Si le décompte dépasse la capacité lors de l'ajout d'un élément, la capacité de la liste est doublée en réaffectant automatiquement le tableau interne.
Si la valeur de capacité est explicitement définie, le réseau interne doit également être réaffecté pour s'adapter à la capacité spécifiée. Si la capacité est explicitement définie sur 0, le runtime de langue commune le définit sur sa capacité par défaut. La capacité par défaut est de 16.
Après avoir appelé Clear, le nombre est de 0, et à ce moment la baisse de la capacité est la capacité par défaut de 16, pas 0
3. PublicVirtualVoidTrimTosize ();
Réglez la capacité au nombre réel d'éléments dans l'arrayList.
Si vous n'ajoutez pas de nouveaux éléments à la liste, cette méthode peut être utilisée pour minimiser la surcharge du système de mémoire de la liste.
Pour effacer complètement tous les éléments de la liste, appelez la méthode claire avant d'appeler Trimtosize. Couper une ArrayList vide définira la capacité de ArrayList sur la capacité par défaut, pas zéro.
ArrayList Alist = new ArrayList (); Alist.add ("A"); Alist.Add ("B"); Alist.Add ("C"); Alist.Add ("D"); Alist.Add ("E"); // Count = 5, Capacité = 16, Alist.TrimTosize (); // Count = Capacité = 5; 8. Analyse du code source
Une classe d'implémentation de l'interface de liste, utilise en interne un tableau pour stocker les valeurs des éléments, ce qui équivaut à un tableau de taille variable.
1. Signature
Classe publique ArrayList <E> étend AbstractList <E> implémente List <e>, RandomAccess, clonable, sérialisable
Vous pouvez voir qu'ArrayList hérite de la classe AbstractList Abstract, qui met en œuvre la plupart des méthodes de l'interface de liste. Si vous souhaitez implémenter une liste immuable, héritez simplement de cette classe et implémentez les méthodes GET (int) et taille. Si vous souhaitez implémenter une liste mutable, vous devez remplacer l'ensemble (int, e). De plus, si la taille de la liste est variable, les méthodes ADD (int, e) et supprimer () doivent également être remplacées.
2. Constructeur
ArrayList fournit trois constructeurs:
ArrayList () ArrayList (Collection <? Étend E> C) ArrayList (int InitialCapacity)
La convention d'interface de collecte que chaque classe de collecte doit fournir deux constructeurs "standard", l'un est un constructeur sans paramètres (le premier ci-dessus), et l'autre est un constructeur avec un seul paramètre (le second ci-dessus). ArrayList fournit également un troisième constructeur qui accepte une valeur int pour définir la taille initiale d'Arrayli (la taille par défaut est 10).
3. Méthodes connexes
TRIMTOSIZEPUBLIC VOID TRIMTOSIZE () {ModCount ++; int oldcapacity = elementData.length; if (size <oldcapacity) {elementData = arrays.copyof (elementData, size); }}Utilisé pour réduire la capacité de ArrayList à sa taille réelle actuelle et réduire la capacité de stockage. Le modCount variable est hérité de AbstractList, enregistrant le nombre de fois où la liste est structurellement modifiée. L'élément de l'arrayList est en fait stocké dans ElementData, qui est déclaré: objet transitoire privé [] elementData; La taille variable est le nombre d'éléments de l'arrayList. Lorsque la taille <capacité ancienne, appelez la méthode des tableaux.
4. Indexof et lasindexof
public int indexof (objet o) {if (o == null) {for (int i = 0; i <size; i ++) if (elementData [i] == null) return i; } else {for (int i = 0; i <size; i ++) if (o.equals (elementData [i])) return i; } return -1; }Ces deux méthodes renvoient l'indice de l'élément spécifié, et nous voulons distinguer si le paramètre est nul. LastIndexof est similaire à l'index, mais la recherche de derrière à l'avant.
5. Assurecapacité
public void assurecapacity (int mincapacity) {if (mincapacity> 0) assurecapacityInternal (mincapacity); } private void assurecapacityInternal (int mincapacity) {modCount ++; // code consciente du trop-plein if (mincapacity - elementData.length> 0) se développer (mincapacité); } private void Grow (int Mincapacity) {// Code de trop-flux int Int OldCapacity = elementData.Length; int newcapacity = oldcapacity + (oldcapacity >> 1); if (newcapacity - mincapacity <0) newCapacity = mincapacity; if (newCapacity - max_array_size> 0) newCapacity = HugeCapacity (mincapacity); // La mincapacité est généralement proche de la taille, il s'agit donc d'une victoire: elementData = arrays.copyof (elementData, newcapacity); }Cette méthode garantit la taille de l'arraylist
6.Add et addall
public void add (int index, e élément) {rangeCheckForAdd (index); AssurecapacityInternal (taille + 1); // incréments modCount !! System.ArrayCopy (élémentData, index, elementData, index + 1, taille - index); elementData [index] = élément; taille ++; } Ajouter (int index, élément e) pour ajouter un élément à la position spécifiée. Tout d'abord, appelez RangcheckForAdd pour vérifier si l'index est valide. Si index> taille || Index <0, une exception sera lancée. Assurez-vous ensuite que la capacité est augmentée de 1 et appelez le système. Enfin, définissez la valeur à l'index sur l'élément ajouté. Il existe également une méthode Add (e e) surchargée qui ajoute directement l'élément à la fin.
Addall (Collection <? étend E> C) et Addall (Int Index, Collection <? Étend E> C) Ajouter tous les éléments de la collection à la fin et aux positions spécifiées respectivement.
7. Réfléchissez et removeall
public booléen retire (objet o) {if (o == null) {for (int index = 0; index <size; index ++) if (elementData [index] == null) {fastRemove (index); Retour Vrai; }} else {for (int index = 0; index <size; index ++) if (o.equals (elementData [index])) {fastRemove (index); Retour Vrai; }} return false; }La méthode de suppression (objet O) supprime l'élément spécifié. Tout d'abord, recherchez l'emplacement de l'élément, puis appelez FastreMove (index) pour le supprimer. Le code est le suivant:
private void fastRemove (int index) {modCount ++; int numMoved = size - index - 1; if (numMoved> 0) // déplacer tous les éléments derrière l'index + 1 un système de position vers l'avant. elementData [- size] = null; // Soit GC faire son travail} La méthode de suppression surchargée (INT INDEX) est utilisée pour supprimer des éléments à l'emplacement spécifié. Removerange (int fromIndex, int toindex) est utilisé pour supprimer tous les éléments entre les emplacements spécifiés.
RemoveAll (Collection <?> C) et retenueall (Collection <?> C) Les codes sont les suivants:
public booléen reroveall (collection <?> c) {objets.RequiRenonnull (c); retour BatchRemove (C, false); } public boolean retenainall (collection <?> c) {objets.RequiRenonnull (c); retour BatchRemove (C, true); }Ils sont tous mis en œuvre en appelant la méthode BatchRemove, et leur code est le suivant:
BOOLEAN PRIVÉ BATCHREMOVE (Collection <?> C, Boolean Complément) {objet final [] ElementData = this.ElementData; int r = 0, w = 0; booléen modifié = false; try {for (; r <size; r ++) if (c.Contains (elementData [r]) == complément) elementData [w ++] = elementData [r]; } Enfin {// Préserve la compatibilité comportementale avec AbstractCollection, // Même si C.Contains () lance. if (r! = size) {System.ArrayCopy (elementData, r, elementData, w, size - r); w + = taille - r; } if (w! = size) {// Effacer pour laisser GC faire son travail pour (int i = w; i <size; i ++) elementData [i] = null; modCount + = size - w; taille = w; modifié = true; }} return modifié; }Cette méthode a deux paramètres. Le premier est la collection d'opérations et la seconde est une valeur booléenne. En le définissant sur true ou false, il sélectionne s'il faut supprimer ou retenue. L'énoncé dans TRY met les autres entre 0 et W, puis finalement le second si en in gère enfin l'espace après W, et le premier est exécuté lorsque C.Contains () lance une exception.