Explication détaillée de l'exemple de problème d'extension Java ArrayList

Cet article étudie principalement les contenus liés des exemples de problèmes d'extension de la liste Java Array, comme suit.

Tout d'abord, nous devons savoir que l'essence d'ArrayList est en fait un tableau de type objet. Le problème d'extension de ArrayList est en fait le problème d'extension de ce tableau de type objet.

 objet transitoire [] elementData;

1. Lors de la création, l'allocation de capacité de ArrayList

Il y a trois situations pour créer une liste d'arraie

1. Création de taille par défaut (par défaut est 0)

 ArrayList al = new ArrayList ();

Une fois la création terminée, la capacité d'Al est 0. Vous pouvez savoir à partir du code suivant.

 objet transitoire [] elementData; objet final statique privé [] defaultCapacity_empty_elementData = {}; public arrayList () {this.elementData = defaultCapacity_empty_elementData;}

2. Créez une taille spécifiée

 ArrayList al = new ArrayList (5);

La création d'un objet ArrayList avec une capacité de 5 est en fait un tableau d'objets avec une longueur de 5. Vous pouvez le savoir à partir du code suivant.

 objet transitoire [] elementData; objet final statique privé [] defaultCapacity_empty_elementData = {}; public arrayList (int initialCapacity) {if (initialCapacity> 0) {this.elementData = new objet [initialCapacity]; } else if (initialCapacity == 0) {this.elementData = vide_elementData; } else {lance un nouveau IllégalArgumentException ("Capacité illégale:" + InitialCapacity); }}

3. Spécifiez la création de collection d'éléments

 ArrayList al = new ArrayList <Integer> (arrays.aslist (1, 2, 3, 4, 5));

L'objet ArrayList est créé ci-dessus et initialisé à l'aide d'une liste comme [1,2,3,4,5]. En fait, il crée un tableau d'objets de longueur 5, et le contenu du tableau est [1, 2, 3, 4, 5]. Vous pouvez savoir à partir du code suivant.

 Taille INT privée; objet transitoire [] ElementData; objet final statique privé [] defaultCapacity_empty_elementData = {}; public arrayList (collection <? étend e> c) {elementData = c.toArray (); if ((size = elementData.Length)! = 0) {// C.ToArray pourrait (incorrectement) non retour objet [] (voir 6260652) if (elementData.getClass ()! = objet []. class) elementData = arrays.copyof (elementData, size, objet []. class); } else {// Remplacez par un tableau vide. this.elementData = vide_elementData; }}

2. Lors de l'insertion d'éléments, la capacité de ArrayList est élargie

 ArrayList <Integer> collection = new ArrayList <Integer> (arrays.aslist (1, 2, 3, 4, 5)); Integer [] Moresits = {6, 7, 8, 9, 10}; collection.addall (arrays.aslist (plusits));

Le processus ci-dessus est le suivant:

1. Créez une liste Array avec la taille 5, avec du contenu [1, 2, 3, 4, 5]. - La capacité initiale est 5

2. Ajouter Set {6, 7, 8, 9, 10} à cet objet ArrayList. --- Pour le moment, la capacité de cet objet ArrayList doit être élargie.

Afficher le code source:

 Public Boolean Addall (Collection <? Étend E> C) {// Obtenez l'objet de tableau d'insertion [] A = C.ToArray (); // Obtenez la longueur du contenu d'insertion int numnew = a.Length; EnsurecapacityInternal (taille + numnew); // incréments modCountSystem.arraycopy (A, 0, ElementData, Size, Numnew); Taille + = NUMBER; 0;} private void assurecapacityInternal (int mincapacity) {// si le contenu dans ArrayList est vide if (elementData == defaultCapacity_Empty_ElementData) {Mincapacity = math.max (default_capacity, minecapacity);} assurexplicity (mincapactity);} private dinging {modCount ++; // Calculez davantage la taille de taille étendue MincapacityIF (Mincapacity - ElementData.Length> 0) Grow (Mincapacity);} Private Void Grown (int Mincapacity) {// La taille d'origine de ArrayList int OldCapacity = ElementData.length; // calculate la taille expansée basée sur la taille d'origine, et la taille étendue est 1.5 Times de la taille de l'élément de la taille de l'élément = OldCapacity + (OldCapacity >> 1); // Comparez avec la longueur d'expansion précédemment calculée Mincapacity, prenez le plus grand comme longueur d'expansion si (Newcapacity - Mincapacity <0) newcapacity = mincapacity; // si la longueur d'expansion est plus grande que la longueur maximale si (newCapacity - Max_Array_Size> 0) Extension elementData = arrays.copyof (elementData, newcapacity);} private static int hugrecapacity (int mincapacity) {// mincapacity est inférieur à 0, indiquant le débordement, sinon le maximum entier est utilisé comme longueur d'expansion finale if (Mincapacité <0) / / déborde Max_Array_Size)? Integer.max_value: max_array_size;}

Le processus ci-dessus peut être résumé comme suit:

1. La taille d'origine de ArrayList + la taille de la collection à insérer numnew = obtenir la longueur minimale de la mincapacité ArrayList élargie

2. Si la taille d'origine de ArrayList est 0, c'est-à-dire, ArrayList est vide, la longueur minimale de ArrayList après l'extension Mincapacity = Math.max (10, mincapacité), c'est-à-dire la longueur minimale de la mineur d'extension n'est pas seulement la taille de longueur d'origine plus le nombre de longueurs de la longueur de l'ensemble d'insertion.

3. La mincapacité minimale élargie obtenue ci-dessus n'est pas la longueur étendue finale et un calcul supplémentaire est nécessaire.

(1) Obtenez la taille d'origine de ArrayList OldCapacity
(2) Obtenez la nouvelle taille étendue: newCapacity = OldCapacity * 1.5;
(3) Comparez la mincapacité de longueur minimale étendue calculée ci-dessus avec la nouvelle capacité de taille élargie obtenue ici, et prenez la plus grande en tant que taille finale élargie.

Résumer

Ce qui précède est toute l'explication détaillée de l'exemple du problème d'extension ArrayList Dans cet article, j'espère que cela sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!