Présentation ArrayList:
ArrayList est implémenté en fonction des tableaux et est un tableau dynamique dont la capacité peut augmenter automatiquement, similaire à la mémoire d'application dynamique dans le langage C, qui augmente dynamiquement la mémoire.
ArrayList n'est pas en filetage et ne peut être utilisé que dans un environnement unique. Dans un environnement multi-thread, vous pouvez envisager d'utiliser la fonction CollectionS.SynchronizeList (List L) pour renvoyer une classe ArrayList de filetage, ou vous pouvez utiliser la classe CopyOnwriteArrayList sous un package concurrent simultané.
ArrayList implémente l'interface sérialisable, donc elle prend en charge la sérialisation, peut être transmise par sérialisation, implémente l'interface aléatoire et prend en charge un accès aléatoire rapide. En fait, il est un accès rapide via le numéro de série de l'indice, implémente l'interface clonable et peut être cloné.
Chaque instance ArrayList a une capacité, qui 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. La croissance automatique entraînera une récolte des données au nouveau tableau, donc si vous pouvez prédire la quantité de données, vous pouvez spécifier sa capacité lors de la construction d'une liste d'array. Avant d'ajouter un grand nombre d'éléments, l'application peut également utiliser l'opération d'assurance pour augmenter la capacité de l'instance ArrayList, ce qui peut réduire le nombre de redistributions incrémentielles.
Notez que cette implémentation n'est pas synchrone. 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 rester synchronisé en externe.
Faisons un enregistrement et un résumé de Java ArrayList
classe publique ArrayList <e> {/ ** * Éléments qui stockent la collection * * / objet transitoire privé [] ElementData; / ** Taille d'élément * / Taille privée INT;Définissez une classe générique, un tableau d'objet et une variable privée pour enregistrer le nombre d'éléments dans la collection. Il existe une variable privée supplémentaire dans le texte d'origine, et je ne sais pas quoi l'utiliser, et l'auteur n'a aucune explication ni le mentionner. Ce n'est pas grave si je ne l'ai pas utilisé.
/ ** * Initialiser en fonction de la taille spécifiée * @param initialCapacity * / public ArrayList (int initialCapacity) {super (); if (initialCapacity <= 0) {// exception Throw New illégalArgumentException ("Le paramètre d'initialisation ne peut pas être inférieur à 0"); } else {// initialiser le tableau this.elementData = nouvel objet [initialCapacity]; }} / ** * Initialisation par défaut * / public arrayList () {this (10); } / ** * Initialiser selon une classe de collection * @param c Une classe qui doit hériter de l'interface de collection * / public arrayList (collection <? Étend e> c) {// initialize elementData = c.toArray (); size = elementData.length; // convertit le type d'objet if (elementData.getClass ()! = Objet []. Class) {elementData = arrays.copyof (elementData, size, object []. Class); }} 3 Méthodes d'initialisation, initialisez le tableau en fonction de la taille par défaut, initialisez la taille donnée et transmettez une classe qui hérite de l'interface de collection de collecte pour l'initialisation de l'attribution de la conversion
/ ** * Collection d'extension * @param mincapacity * / public void assurecapacity (int mincapacity) {/ ** Taille actuelle du tableau * / int oldcapacity = elementData.length; if (mincapacity> oldcapacity) {/ ** * Bien que OldData ne soit pas utilisé, il s'agit de gestion de la mémoire et que la variable ElementData ne se réfère pas à la variable ElementData pendant le cycle de vie de la méthode IF, il ne sera donc pas recyclé par gc * allouant la mémoire de la mémoire ElementData sans empiéter. * Lorsque la fin part si, le cycle olddata se termine et est recyclé * / objet olddata [] = elementData; int newcapacity = (oldcapacity * 3) / 2 + 1; // augmenter 50% + 1 if (newcapacity <mincapacity) newcapacity = mincapacity; // Utilisez des arrays.copyof pour copier les éléments de la collection et générer un nouveau tableau ElementData = arrays.copyof, newCapacity); }}Il s'agit d'une méthode de base. L'expansion de l'ensemble est en fait de comparer l'expansion du tableau et la taille de la collection de mincapacité pour déterminer si elle doit être élargie. La méthode Arrays.Copyof () est utilisée pour l'expansion.
Le texte original a une explication détaillée. Cette méthode copie le contenu du premier paramètre à un nouveau tableau. La taille du tableau est le deuxième paramètre et renvoie un nouveau tableau. Il existe des commentaires détaillés sur les variables d'Olddata.
/ ** * Vérifiez si l'index est hors limites * @param index * / private void RangECHeck (int index) {if (index> size || index <0) {throw new indexoutofboundSException ("indicateur dépasse, index:" + index + ", size:" + size); }}Si une recherche d'indice est 1 / **
* Ajouter l'élément * Ajouter l'élément spécifié à la fin de la collection * @param e élément ajouté * @return * / public boolean add (e e) {Ensurecapacité (taille + 1); elementData [size] = e; taille ++; Retour Vrai; }Ajoutez un élément, développez d'abord la capacité, attribuez la valeur, puis ajoutez l'élément. Notez que la taille + 1 de la taille du champ n'est pas ajoutée une. Voici une opération arithmétique, il est donc nécessaire de l'augmenter plus tard.
/ ** * Ajouter un élément * Ajouter un élément à la position spécifiée * @param index index index index élément élément * @param élément * @return * / public boolean add (int index, e élément) {rangecheck (index); asurecapacité (taille + 1); // élément ElementData à partir de la position d'index et de la longueur de la taille-indice, // Copiez dans un nouveau tableau ElementData à partir de la position d'index comme index + 1. // Cela signifie que l'élément actuellement dans cette position et tous les éléments suivants sont déplacés juste par une seule position. System.ArrayCopy (élémentData, index, elementData, index + 1, taille-index); elementData [index] = élément; Size ++; // Ajouter l'élément un rendement true; }La différence ici est System.ArrayCopy (élémentData, index, elementData, index + 1, taille-index);
Il s'agit d'une méthode interne de c. Le texte original détaillé a une explication, donc je n'en parlerai pas ici. Ceci est également le cœur de l'ensemble de la liste Array et également le principe de mise en œuvre interne des tableaux.copyof ()
/ ** * Ajouter tous les éléments * Ajouter tous les éléments de la collection à la fin de cette liste dans l'ordre des éléments renvoyés par l'itérateur de la collection spécifiée. * @param c * @return * / public boolean addall (collection <? étend e> c) {objet [] newelement = c.toarray (); int elementLength = newelement.length; asurecapacité (taille + elementLength); // à partir de l'indice de Newelement 0, ElementLength Elements, ElementData Taille Indice System.ArrayCopy (NewElement, 0, ElementData, Size, ElementLength); taille + = elementLength; return elementLength! = 0; }Fondamentalement, d'autres méthodes effectuent uniquement un traitement différent en fonction de différentes situations, telles que le passage des objets de données dans l'interface et l'obtention de la longueur pour l'expansion, et la copie des données dans un nouveau tableau à l'aide du système et de l'arraycopie.
/ ** * Spécifiez la position, ajoutez tous les éléments * @Param Index INSERT Position Index * @param C Collection des éléments insérés * @return * / public boolean addall (int index, collection <? Étend e> c) {if (index> size || index <0) {throw new indexoutofboundSexception ("index:" + index + ", size:" + size); } Objet [] newelement = c.toArray (); int elementLength = newelement.length; asurecapacité (taille + elementLength); int numMoved = size-index; // jugez si la position d'insertion est au milieu du tableau if (numMoved> 0) {// déplace tous les éléments derrière la position d'insertion d'index à l'arrière // Insérez les éléments NumMoved commençant à partir de l'index d'index index dans l'index + ElementLength Position de ElementData Data System.ArrayCopy (ElementData, index, index + elementLength, NumMoved); } // Ajouter ElementLength dans Newelement de 0 à la position où ElementData Index démarre System.ArrayCopy (Newelement, 0, ElementData, Index, ElementLength); taille + = elementLength; return elementLength! = 0; } / ** * Spécifiez la valeur de l'index * @param index * @param élément * @return * / public e set (int index, e élément) {rangeCheck (index); E oldElement = (e) elementData [index]; elementData [index] = élément; Retour OldElement; } / ** * Obtenez la valeur basée sur l'index * @param index * @return * / public e get (int index) {RangECheck (index); return (e) elementData [index]; } / ** * Supprimer l'élément en fonction de l'indice * @param index * / public e re Support (int index) {rangeCheck (index); E oldElement = (e) elementData [index]; / ** Le nombre d'éléments après l'indice supprimé * / int numMoved = size-index-1; // S'il est déplacé dans la plage de tableau si (numMoved> 0) System.ArrayCopy (élémentData, index + 1, elementData, index, numMoved); // supprimer elementData [- size] = null; Retour OldElement; } / ** * supprimer selon l'élément * @param obj * @return * / public boolean retire (objet obj) {// ArrayList permet Null, donc le traitement du jugement doit également être effectué if (obj == null) {for (int index = 0; index <size; index ++) {if (elementData [index] == null) {retire (index); Retour Vrai; }}} else {for (int index = 0; index <size; index ++) {if (obj.equals (elementData [index])) {retire (index); Retour Vrai; }}} return false; } / ** * Supprimez les éléments dans la plage spécifiée en fonction de l'indice * @param fromindex start * @param toindex end * / protected void Removerange (int fromIndex, int toindex) {rangeCheck (fromIndex); Ranghecheck (toindex); // le nombre d'éléments à déplacer int numMoved = size - toindex; // déplacez l'élément derrière ToIndex vers FromIndex System.arrayCopy (ElementData, Toindex, ElementData, FromIndex, NumMoved); // le nombre d'éléments à supprimer int newsize = size- (toindex-fromidex); while (size! = newsize) {elementData [-size] = null; }} / ** * Ajustez la capacité du tableau à la capacité réelle * / public void trimToSize () {int length = elementData.length; if (size <leng) {objet [] old = elementData; elementData = arrays.copyof (elementData, taille); }} / ** * Convertir les éléments de collecte en tableau * @return * / objet public [] toArray () {return arrays.copyof (elementData, size); } public <T> t [] toArray (t [] a) {if (a.length <size) {return (t []) arrays.copyof (elementData, size, a.getClass ()); } // Copiez l'élément de collection dans le tableau asystem.arraycopy (elementData, 0, a, 0, taille); if (a.length> size) {for (int index = size; index <a.Length; index ++) {a [index] = null; }} return a; } Fondamentalement, il s'agit de faire fonctionner le tableau et d'utiliser des méthodes C pour attribuer des valeurs et les déplacer. Vous pouvez afficher le texte d'origine en détail. Il n'y a pas beaucoup de problèmes dans le texte d'origine, à l'exception de la variable privée, et le code peut fonctionner parfaitement. La difficulté de ceci et l'utilisation de la variable oldata dans la méthode d'expansion seront les deux méthodes de système, ArrayCopy et Arrayist.copy () et l'utilisation de la variable olddata dans la méthode d'expansion. Cette variable est vraiment bonne. Au début, je ne savais pas pourquoi je l'ai utilisé comme ça, et je l'expliquerai à la fin du texte d'origine.
Ce qui précède est un exemple d'explication de la mise en œuvre de Java ArrayList qui vous est présenté par l'éditeur. J'espère que cela vous sera utile. Si vous avez des questions, laissez-moi un message. L'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web du réseau Wulin!