ArrayList
Die zugrunde liegende Implementierung ist ein Array, das einen hohen Effizienz beim Zugriff auf Elemente hat (schnelle Abfrage, langsame Einfügung, Modifikation und Löschen von Elementen)
Im Vergleich zur LinkedList ist es effizient, aber Thread-Safe.
ArrayList -Array ist ein veränderliches Array, das auf alle Elemente zugreifen kann, einschließlich Null
Die zugrunde liegende Implementierung erfolgt mit Arrays
transientes Objekt [] elementData;
Konstruktionsmethode
private statische endgültige int default_capacity = 10; privates statisches endgültiges Objekt [] leere_elementData = {}; privates statisches endgültiges Objekt [] defaultCapacity_Empty_elementData = {}; transientes Objekt [] elementData; private Int -Größe; // Erstellen Sie eine leere Liste public arrayList () {this.elementData = defaultCapacity_Empty_elementData; } // Erstellen Sie eine leere Liste der angegebenen Erstkapazität öffentliche ArrayList (init initialCapacity) {if (initialCapacity> 0) {this.elementData = neues Objekt [initialCapacity]; } else if (initialCapacity == 0) {this.elementData = leer_elementData; } else {werfen neuer illegalArgumentException ("illegale Kapazität:"+ initialCapacity); }} // Erstellen Sie eine Liste bestimmter Sammlungselemente, die in der Reihenfolge der iterativen Rückgabe der Verbindungselemente öffentlich ArrayList angeordnet sind (Sammlung <? Erweitert E> c) {elementData = C.toarray (); if ((size = elementData.Length)! } else {// Ersetzen Sie durch leeres Array. this.elementData = leer_elementData; }}Lagerung
// Das Element an der angegebenen Position der Liste wird durch Element ersetzt, und das ursprüngliche Element an dieser Position wird öffentlich E -Set (int Index, E -Element) {Rangecheck (Index) zurückgegeben; // Überprüfen Sie die Array -Kapazität und den Wurf: IndexoutOfBoundSexception e oldValue = elementData (Index); elementData [index] = element; kehren Sie OldValue zurück; } // Fügen Sie das angegebene Element am Ende der Liste öffentlich boolean add (e e) {sealEcapacityInternal (Größe + 1) hinzu; // Array -ExpansionselementData [Größe ++] = e; zurückkehren; } // Das Element in der angegebenen Position der Liste der Liste öffentlich boolean add (e e) {sealEcapacityInternal (Größe ++] = e; return true;} // Fügen Sie das Element an der angegebenen Position des list öffentlichen void add (int Index, E -Element) {rangecheckForadd (Index); SRCPRO: Startposition im Quellarray // Dest: Zielarray, Startposition des Zielarrays, Länge: Anzahl der Array -Elemente, die die Elemente derzeit kopieren sollen, und alle nachfolgenden Elemente ein Positionssystem. Fügen Sie die Elemente in der Verbindung am Ende der Liste hinzu, und die Elemente sind in der Reihenfolge der Verbindungs -Iteratorin öffentlicher Boolean addall zurückgegeben. 0, ElementData, Numnew); sealecapacityInternal (Größe + numNew);Lesen
// Entfernen Sie das Element an der angegebenen Position dieser Liste öffentlich E REMET (INT INDEX) {RANGECHECK (INDEX); ModCount ++; E oldValue = elementData (index); int nummoved = Größe - Index - 1; if (nummoved> 0) system ElementData [-Größe] = NULL; // klar, dass GC seine Arbeit erledigt OldValue; } // ein Element in dieser Liste entfernen public boolean entfernen (Objekt o) {if (o == null) {for (int index = 0; index <size; index ++) if (elementData [index] == null) {fastReMove (index); zurückkehren; }} else {for (int index = 0; index <size; index ++) if (o.equals (elementData [index])) {fastremove (index); zurückkehren; }} return false; } private void fastremove (int index) {modcount ++; int nummoved = Größe - Index - 1; if (nummoved> 0) system ElementData [-Größe] = NULL; // klare, um GC seine Arbeit zu erledigen}Array -Erweiterung
Immer wenn ein Element zu einem Array hinzugefügt wird, muss prüfen, ob die Anzahl der Elemente nach dem Hinzufügen von Elementen die Länge des aktuellen Arrays überschreitet. Wenn es die Länge überschreitet, wird das Array erweitert, um den Anforderungen des Hinzufügens zu erfüllen.
public void searecapacity (int mincapacity) {int minexpand = (elementData! = defaultCapacity_empty_elementData)? 0: default_capacity; if (mincapacity> minexpand) {safexplicitCapacity (mincapacity); }} private void sealecapacityInternal (int mincapacity) {if (elementData == defaultCapacity_Empty_elementData) {mincapacity = math.max (default_capacity, mincapacity); } sorgenexplicitCapacity (mincapacity); } private void sorgenexplicitCapacity (int mincapacity) {modcount ++; // überlaufbewusster Code if (mincapacity - elementData.length> 0) wachsen (minkapazität); } private void Grow (int mincapacity) {// Überlauf-unbewusster Code int oldCapacity = elementData.length; int newCapacity = OldCapacity + (OldCapacity >> 1); if (newcapacity - mincapacity <0) newCapacity = mincapacity; if (newcapacity - max_array_size> 0) newCapacity = Hugcapacity (mincapacity); // Hackigkeit liegt normalerweise nahe an der Größe, daher ist dies ein Gewinn: elementData = arrays.copyof (elementData, Newcapacity); } private statische int Hugenkapazität (int mincapacity) {if (mincapacity <0) // Überlauf neu aus outofMemoryError (); return (mincapacity> max_array_size)? Integer.max_value: max_array_size; }Handgeschriebene ArrayList
öffentliche Klasse myArrayList /*implementiert die Liste <e>* /{private transiente Objekt [] elementData; private intgröße; // Anzahl der Elemente public myarrayList () {this (10); } public myArrayList (int initialCapacity) {if (initialCapacity <0) {try {thrower New Exception (); } catch (Ausnahme e) {e.printstacktrace (); }} elementData = neues Objekt [initialCapacity]; } public int size () {return size; } public boolean isempty () {return size == 0; } // das Objekt gemäß dem Index public void remove (int index) löscht Ausnahme {rangecheck (index); int nummoved = size-Index-1; if (numMoved> 0) {System.ArrayCopy (ElementData, Index+1, elementData, Index, numMoved); } elementData [-size] = null; } // Das Objekt öffentlich boolean entfernen (Objekt obj) löst Ausnahme aus {für (int i = 0; i <size; i ++) {if (get (i) .Equals (obj)) {remove (i); } Return true; } Return true; } // Das Element Public Object Set (int Index, Object OBJ) löst Ausnahme {rangecheck (index) aus; Objekt oldValue = elementData [index]; elementData [index] = obj; kehren Sie OldValue zurück; } // Das Element in der angegebenen Position einfügen public void add (int index, Object obj) löst eine Ausnahme aus {rangecheck (index); SEELEALECAPACITY (); System.ArrayCopy (ElementData, Index, ElementData, Index+1, Größe-Index); elementData [index] = obj; Größe ++; } public void add (Object Object) {sealEcapacity (); /*elementData [Größe] = Objekt; Größe ++;*/ elementData [Größe ++] = Objekt; // Wert zuerst zuweisen, dann erhöhen Sie sich selbst} öffentliches Objekt erhalten (int Index) Ausnahme {rangecheck (index); return elementData [index]; } public void rangecheck (int index) löst Ausnahme aus {if (index <0 || index> = Größe) {neue Ausnahme werfen (); }} // public void sealeCapacity erweitern () {// Array -Erweiterung und Inhaltskopie if (size == elementData.length) {// elementData = neues Objekt [Größe*2+1]; Schreiben Sie auf diese Weise den Inhalt im ursprünglichen Array verloren. // den Inhalt im Array/*für (int i = 0; i <newArray.length; i ++) {newArray [i] = elementData [i] kopieren; }*/ System.ArrayCopy (elementData, 0, newArray, 0, elementData.length); elementData = newArray; }} // public static void main (String [] args) {myarrayList myarrayList = new MyArrayList (3); myarrayList.add ("111"); myarrayList.add ("222"); myarrayList.add ("333"); myarrayList.add ("444"); myarrayList.add ("555"); Versuchen Sie {myarrayList.remove (2); myarrayList.add (3, "neuer Wert"); myarrayList.set (1, "modify"); } catch (Ausnahme e1) {// Todo automatisch generatter Block e1.printstacktrace (); } System.out.println (myarrayList.size ()); für (int i = 0; i <myarrayList.size (); i ++) {try {System.out.println (myarrayList.get (i)); } catch (Ausnahme e) {e.printstacktrace (); }}}}