L'arrayList sous-jacent maintient un tableau dynamique et chaque instance ArrayList a une capacité. Cette capacité fait référence à la taille du tableau utilisé pour stocker les éléments de la liste. Il est toujours au moins égal à la taille de la liste. Étant donné que les éléments sont constamment ajoutés à l'arraylist, leur capacité augmente également automatiquement.
ArrayList n'est pas synchrone (c'est-à-dire pas de thread-safe). Si plusieurs threads accèdent à une instance ArrayList en même temps et qu'au moins l'un des threads modifie structurellement la liste, il doit maintenir la synchronisation externe. Dans un environnement multi-thread, une liste Array-SAFE peut être déclarée à l'aide de la méthode Collection.SynchronizedList, par exemple:
List arrayList = collections.SynchronizedList (new ArrayList ());
Ce qui suit est le code source de ArrayList pour analyser son principe.
1. Méthode de construction ArrayList: ArrayList fournit trois méthodes de construction différentes
1) ArrayList (), construire une liste vide avec une capacité initiale de 10.
2) ArrayList (int initialCapacity), construisant une liste vide avec une capacité initiale spécifiée.
3) ArrayList (Collection <? Étend E> C), construit une liste d'éléments contenant la collection spécifiée, qui sont organisées dans l'ordre dans lequel l'itérateur de la collection les renvoie.
Le code source est le suivant:
objet transitoire privé [] elementData; public arrayList (int initialCapacity) {super (); if (InitialCapacity <0) lancez un nouveau IllégalArgumentException ("Capacité illégale:" + InitialCapacity); this.elementData = nouvel objet [initialCapacity]; // Générez un tableau de type d'objet de longueur 10} public arrayList () {this (10); // Appel ArrayList (int i)} <br> <br> public ArrayList (Collection <? Étend E> C) {elementData = c.toArray (); // Renvoie un tableau contenant tous les éléments de cette taille de collection = elementData.Length; // C.ToArray pourrait (incorrectement) non retour objet [] (voir 6260652) if (elementData.getClass ()! = objet []. class) elementData = arrays.copyof (elementData, size, objet []. class); // Copiez le tableau spécifié et renvoyez un tableau de type d'objet contenant le même élément et la même longueur} Lorsque vous utilisez ArrayList () pour générer un objet de collecte sans paramètres, le constructeur ArrayList (int initialCapacity) est appelé en bas pour produire un tableau de type d'objet avec la longueur 10. Lorsque vous utilisez un constructeur avec des paramètres de type de définition, un tableau de type d'objet contenant les mêmes éléments et la longueur est généré en bas.
2. Ajouter la méthode: ArrayList fournit deux méthodes d'ajout pour ajouter des éléments
1) Ajouter (E E), ajouter l'élément spécifié à la fin de cette liste.
2) Ajouter (int index, e e), insérer l'élément spécifié dans la position spécifiée dans cette liste. Déplacez à droite l'élément actuellement dans cette position (le cas échéant) et tous les éléments suivants (indexés par 1) la taille int privée;
public booléen add (e e) {assurecapacité (taille + 1); // Développez la capacité du tableau ElementData [Taille ++] = E; // Ajouter l'élément E au tableau d'objets avec la taille des indices et exécuter la taille ++ return true; } public void add (int index, e élément) {if (index> size || index <0) // Si l'indice de tableau spécifié à insérer dépasse la capacité du tableau ou si l'indice spécifié est inférieur à 0, lancez une exception lance une nouvelle indexoutofboundSexception ("index:" + index + ", size:" + size); asurecapacité (taille + 1); // Développez le système de capacité du tableau.ArrayCopy (élémentData, index, elementData, index + 1, taille - index); // Copiez un tableau à partir du tableau source spécifié, et la copie commence à partir de la position spécifiée à la position spécifiée du tableau cible. <br> // ElementData --- Index du tableau source --- Position de démarrage dans le tableau source <br> // ElementData --- Index du tableau cible + 1 --- Position de démarrage dans le tableau cible <br> // Taille - Index --- Nombre d'éléments de tableau à copier elementData [index] = élément; // Mettez l'élément à ajouter à la taille de l'index du tableau spécifié ++; } public void assurecapacity (int mincapacity) {modCount ++; int oldcapacity = elementData.length; // La capacité du tableau d'origine if (mincapacity> oldcapacity) {object olddata [] = elementData; int newcapacity = (oldcapacity * 3) / 2 + 1; // Définissez la capacité du nouveau tableau, qui est 1,5 fois la capacité du tableau d'origine +1 if (newcapacity <mincapacity) newcapacity = mincapacity; // La mincapacité est généralement proche de la taille, il s'agit donc d'une victoire: elementData = arrays.copyof (elementData, newcapacity); // Copiez le tableau spécifié et renvoyez la capacité du nouveau tableau en tant que nouvellecapacité}} Si plus de 10 éléments sont ajoutés dans la collection, la couche inférieure ArrayList générera un nouveau tableau avec une longueur de 1,5 fois + 1 du tableau d'origine, et copiera les éléments du tableau d'origine dans le nouveau tableau, et les éléments ajoutés ultérieurs seront placés dans le nouveau tableau. Ce processus est répété lorsque la longueur du nouveau tableau ne peut pas s'adapter aux éléments nouvellement ajoutés. Il s'agit du principe de mise en œuvre de l'ajout d'éléments à une collection.
3. Obtenez la méthode:
1) get (int index), renvoyez l'élément à la position spécifiée dans cette liste.
public e get (int index) {rangeCheck (index); // Vérifiez si l'indice spécifié adopté est un rendement légal (e) elementData [index]; // Renvoie l'élément de tableau avec l'index d'indice d'indice du tableau} private void RangECHeck (int index) {if (index> = size) // Si l'indice entrant est supérieur ou égal à la capacité de l'ensemble, lancez une exception lance un nouvel indexoutofboundSexception ("index:" + index + ", size:" + size); } 4. Supprimer la méthode:
1) E REPORT (INT INDEX), supprimez l'élément à la position spécifiée dans cette liste. Déplacez tous les éléments suivants vers la gauche (diminution de leur indice par 1).
2) Booléen Supprime (objet O), supprimez l'élément spécifié qui apparaît pour la première fois dans cette liste (si présente). Si la liste ne contient pas cet élément, la liste ne sera pas modifiée et la valeur booléenne sera renvoyée.
public e re Support (int index) {rangeCheck (index); // Vérifiez si l'index spécifié est légal ModCount ++; E oldvalue = (e) elementData [index]; // Obtenez l'élément de tableau de l'index spécifié int numMoved = size - index - 1; // le nombre d'éléments à déplacer si (numMoved> 0) System.ArrayCopy (élémentData, index + 1, elementData, index, numMoved); // déplacez l'élément d'élément de tableau [- taille] = null; // Laissez GC faire son travail retourne OldValue; } public boolean retire (objet o) {if (o == null) {// si le paramètre passé est null pour (int index = 0; index <size; index ++) if (elementData [index] == null) {// supprimer la première occurrence de Null FastreMove (index); Retour Vrai; }} else {for (int index = 0; index <size; index ++) if (o.equals (elementData [index])) {fastRemove (index); Retour Vrai; }} return false; } private void fastRemove (int index) {// supprimer l'élément à la position spécifiée, la méthode d'implémentation est similaire à supprimer (int i) modCount ++; int numMoved = size - index - 1; if (numMoved> 0) System.ArrayCopy (elementData, index + 1, elementData, index, numMoved); elementData [- size] = null; // Soit GC faire son travail} 5. Méthode de clone:
1) Object Clone (), renvoie une copie peu profonde de cette instance ArrayList (pas de copie de ces éléments eux-mêmes).
public objet clone () {try {arrayList <e> v = (arrayList <e>) super.clone (); // Calcul de la méthode de clone de la classe d'objets pour renvoyer un objet ArrayList v.ElementData = arrays.copyof (elementData, size); // Copiez le tableau cible v.modCount = 0; retour v; } catch (clonenotsupportedException e) {// Cela ne devrait pas se produire, car nous jetons clonéable New InternError (); }} L'analyse ci-dessus de certains codes source clés de ArrayList, nous connaissons le principe de mise en œuvre sous-jacent de ArrayList. Il y a les points et points suivants pour le code source ArrayList:
1) La couche sous-jacente de ArrayList est implémentée en fonction des tableaux, et l'élément cible peut être trouvé avec précision à travers les normes suivantes, de sorte que l'efficacité de recherche est élevée; Cependant, l'ajout ou la suppression des éléments impliquera le mouvement de position d'un grand nombre d'éléments, ce qui est inefficace.
2) ArrayList fournit trois méthodes de construction différentes. La méthode de construction sans paramètres génère un tableau de type d'objet avec une longueur de 10 par défaut à la couche inférieure. Lorsque le nombre d'éléments ajoutés dans l'ensemble est supérieur à 10, le tableau se développera automatiquement, c'est-à-dire générer un nouveau tableau et placer les éléments du tableau d'origine dans le nouveau tableau.
3) La méthode d'assurance développe le tableau, qui générera un nouveau tableau avec une longueur de 1,5 fois + 1 du tableau d'origine. Au fur et à mesure que les éléments sont constamment ajoutés à l'arrayList, répétez le processus lorsque la longueur du tableau ne peut pas répondre aux besoins.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.