Die zugrunde liegende ArrayList verwaltet ein dynamisches Array, und jede ArrayList -Instanz hat eine Kapazität. Diese Kapazität bezieht sich auf die Größe des Arrays, das zum Speichern von Listenelementen verwendet wird. Es ist immer mindestens der Größe der Liste. Da Elemente ständig zur ArrayList hinzugefügt werden, steigt ihre Kapazität auch automatisch an.
ArrayList ist nicht synchron (dh nicht mit Thread-Safe). Wenn mehrere Threads gleichzeitig auf eine ArrayList -Instanz zugreifen, und mindestens einer der Threads die Liste strukturell ändern, muss sie die externe Synchronisation beibehalten. In einer Umgebung mit mehreren Threads kann beispielsweise eine thread-sichere ArrayList mit der Methode der Collections.SynchronizedList deklariert werden, beispielsweise:
List ArrayList = Collections.synchronizedList (New ArrayList ());
Das Folgende ist der Quellcode von ArrayList, der sein Prinzip analysiert.
1. ArrayList -Konstruktionsmethode: ArrayList bietet drei verschiedene Konstruktionsmethoden
1) ArrayList (), konstruieren Sie eine leere Liste mit einer anfänglichen Kapazität von 10.
2) ArrayList (int initialCapacity), die eine leere Liste mit einer angegebenen Anfangskapazität erstellen.
3) ArrayList (Sammlung <? Erweitert E> c) erstellt eine Liste von Elementen, die die angegebene Sammlung enthalten, die in der Reihenfolge angeordnet sind, in der die Iteratorin der Sammlung sie zurückgibt.
Der Quellcode lautet wie folgt:
private transient Object [] elementData; public arrayList (int initialCapacity) {Super (); if (initialCapacity <0) neue IllegalArgumentException ("illegale Kapazität:"+ initialCapacity); this.elementData = neues Objekt [initialCapacity]; // generieren Sie ein Array von Objekttypen von Länge 10} public arrayList () {this (10); // rufen Sie ArrayList (int i)} <br> <br> public arrayList (Sammlung <? Erweitert E> c) {elementData = c.toarray (); // Zurück ein Array, das alle Elemente in dieser Sammlungsgröße = elementData.length enthält; // c.toarray könnte (falsch) nicht das Objekt [] zurückgeben [] (siehe 6260652) if (elementData.getClass ()! = Object []. Klasse) elementData = arrays.copyof (elementData, Größe, Objekt []. Klasse); // Kopieren Sie das angegebene Array und geben Sie ein Array von Objekttypen zurück, das das gleiche Element und die gleiche Länge enthält} Bei Verwendung von ArrayList (), um ein Sammelobjekt ohne Parameter zu generieren, wird der Konstruktor der ArrayList (int initialCapacity) unten aufgerufen, um ein Array von Objekttypen mit Länge 10 zu erstellen. Bei Verwendung eines Konstruktors mit festgelegten Parametern wird ein Array von Objekttypen, das dieselbe Elemente und Länge enthält, am unteren Bereich generiert.
2. Methode hinzufügen: ArrayList bietet zwei Methoden hinzufügen, um Elemente hinzuzufügen
1) Fügen Sie (e e) das angegebene Element zum Ende dieser Liste hinzu.
2) Hinzufügen (intindex, e e), fügen Sie das angegebene Element in die angegebene Position in dieser Liste ein. Bewegen Sie das derzeit derzeit in dieser Position (falls vorhanden) und alle nachfolgenden Elemente (indiziert durch 1) private int -Größe;
public boolean add (e e) {searecapacity (Größe + 1); // Erweitern Sie die Array -Kapazitätselementdata [Größe ++] = e; // Element E zum Objektarray mit der Einweisgröße hinzufügen und Größe ++ Return True ausführen. } public void add (int index, e element) {if (index> Größe || Index <0) // Wenn das angegebene Array -Sendekript die Array -Kapazität überschreitet, oder das angegebene Index von weniger als 0, werfen Sie einen neuen IndexoutOfBoundSexception ("Index:"+Index+", Größe:"+Größe); Sicherungspunkte (Größe+1); // das Array -Kapazitätssystem erweitern. // Kopieren Sie ein Array aus dem angegebenen Quellarray, und die Kopie startet von der angegebenen Position in die angegebene Position des Zielarrays. <br> // elementData --- // das Element an der angegebenen Array -Indexgröße ++ hinzugefügt werden; } public void Seesecapacity (int mincapacity) {modcount ++; int oldCapacity = elementData.length; // Die Kapazität des ursprünglichen Arrays if (mincapacity> OldCapacity) {Object OldData [] = elementData; int newcapacity = (OldCapacity * 3)/2 + 1; // Definieren Sie die Kapazität des Neuarrays, das das 1,5 -fache der Kapazität des ursprünglichen Arrays +1 beträgt, wenn (Newcapacity <mincapacity) newCapacity = mincapacity; // Hackigkeit liegt normalerweise nahe an der Größe, daher ist dies ein Gewinn: elementData = arrays.copyof (elementData, Newcapacity); // Kopieren Sie das angegebene Array und geben Sie die Kapazität des Neuarray als Newcapacity}} zurück Wenn in der Sammlung mehr als 10 Elemente hinzugefügt werden, erzeugt die untere Schicht der ArrayList ein neues Array mit einer Länge von 1,5 -mal + 1 des ursprünglichen Arrays und kopiert die Elemente im ursprünglichen Array in das Neue Array, und nachfolgende zusätzliche Elemente werden im neuen Array platziert. Dieser Vorgang wird wiederholt, wenn die Länge des neuen Arrays die neu hinzugefügten Elemente nicht aufnehmen kann. Dies ist das Implementierungsprinzip beim Hinzufügen von Elementen zu einer Sammlung.
3. Methode erhalten:
1) GET (INT -Index), geben Sie das Element an der angegebenen Position in dieser Liste zurück.
public e get (int index) {rangecheck (index); // Überprüfen Sie, ob der angegebene Index in der Rechtsrendite (e) elementData [Index]; // Rückgabe das Array -Element mit dem Array -SubScript -Index} private void rangecheck (int index) {if (index> = size) // Wenn das eingehende Index größer oder gleich der Kapazität des Satzes ist, werfen Sie einen neuen IndexoutOfBoundSexception ("Index:"+index+", Größe:"+Größe); } 4. Methode entfernen:
1) E entfernen (int Index), entfernen Sie das Element an der angegebenen Position in dieser Liste. Bewegen Sie alle nachfolgenden Elemente nach links (Abnahme ihres Index um 1).
2) Boolesche Entfernen (Objekt O), entfernen Sie das angegebene Element, das zum ersten Mal in dieser Liste angezeigt wird (falls vorhanden). Wenn die Liste dieses Element nicht enthält, wird die Liste nicht geändert und der boolesche Wert wird zurückgegeben.
public e remove (int index) {rangecheck (index); // Überprüfen Sie, ob der angegebene Index legal modcount ++ ist; E oldValue = (e) elementData [index]; // Erhalten Sie das Array -Element des angegebenen Index int nummoved = Größe - Index - 1; // die Anzahl der Elemente, die bewegt werden sollen, wenn (nummoved> 0) System.ArrayCopy (ElementData, Index+1, ElementData, Index, NumMoved); // Bewegen Sie das Array-ElementelementData [-Größe] = NULL; // GC seine Arbeit erledigen, gibt OldValue zurück; } public boolean remove (Objekt o) {if (o == null) {// if der übergebene Parameter ist null für (int index = 0; index <size; index ++) if (elementData [index] == null) {// Entfernen Sie das erste Vorkommen von 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) {// Entfernen Sie das Element an der angegebenen Position, die Implementierungsmethode ähnelt dem entfernen (int i) modcount ++; int nummoved = Größe - Index - 1; if (nummoved> 0) system ElementData [-Größe] = NULL; // GC seine Arbeit erledigen} 5. Klonmethode:
1) Objekt Clone () gibt eine flache Kopie dieser ArrayList -Instanz zurück (keine Kopieren dieser Elemente selbst).
public Object Clone () {try {ArrayList <E> v = (ArrayList <E>) Super.clone (); // Berechnung der Klonmethode der Objektklasse, um ein ArrayList -Objekt zurückzugeben. // das Zielarray v.modcount = 0 kopieren; Rückkehr v; } catch (clonenotsuptedEdException e) {// Dies sollte nicht passieren, da wir klonbar sind, neue InternalError () zu werfen; }} Die obige Analyse einiger wichtiger Quellcodes von ArrayList kennen das zugrunde liegende Implementierungsprinzip der ArrayList. Es gibt die folgenden Punkte und Punkte für den ArrayList -Quellcode:
1) Die zugrunde liegende Schicht der ArrayList wird basierend auf Arrays implementiert, und das Zielelement kann genau über die folgenden Standards gefunden werden, sodass die Suchseffizienz hoch ist. Das Hinzufügen oder Löschen von Elementen beinhaltet jedoch die Positionsbewegung einer großen Anzahl von Elementen, was ineffizient ist.
2) ArrayList enthält drei verschiedene Konstruktionsmethoden. Die parameterlose Konstruktionsmethode erzeugt ein Array von Objekttypen mit einer Länge von 10 standardmäßig in der unteren Schicht. Wenn die Anzahl der im Set hinzugefügten Elemente größer als 10 ist, erweitert das Array automatisch ein neues Array und platziert die Elemente des ursprünglichen Arrays in das Neue Array.
3) Die Methode für die Sicherungscoapacity -Methode erweitert das Array, das ein neues Array mit einer Länge von 1,5 -fach + 1 des ursprünglichen Arrays erzeugt. Wenn Elemente ständig zur ArrayList hinzugefügt werden, wiederholen Sie den Vorgang, wenn die Array -Länge den Anforderungen nicht erfüllen kann.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.