ArrayList -Übersicht:
ArrayList wird basierend auf Arrays implementiert und ist ein dynamisches Array, dessen Kapazität automatisch wachsen kann, ähnlich wie der dynamische Anwendungsspeicher in der C -Sprache, das den Speicher dynamisch erhöht.
ArrayList ist nicht mit Thread-sicher und kann nur in einer Ein-Thread-Umgebung verwendet werden. In einer Umgebung mit mehreren Threads können Sie in Betracht ziehen, die Funktion der Collections.SynchronizedList (List L) zu verwenden, um eine Thread-Safe-ArrayList-Klasse zurückzugeben, oder Sie können die CopyonWriteArrayList-Klasse unter gleichzeitiger gleichzeitiger Paket verwenden.
ArrayList implementiert die serialisierbare Schnittstelle und unterstützt daher die Serialisierung, kann durch Serialisierung übertragen werden, implementiert die RandomAccess -Schnittstelle und unterstützt einen schnellen Zufallszugriff. Tatsächlich ist es schnell zugreifen, um die Seriennummer des Indexs zu haben, die klonbare Schnittstelle implementiert und kloniert werden kann.
Jede ArrayList -Instanz hat eine Kapazität, die sich auf die Größe des Arrays bezieht, 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. Das automatische Wachstum führt zu einem erneuten Wiederaufbau der Daten zum Neuarray. Wenn Sie also die Datenmenge vorhersagen können, können Sie seine Kapazität beim Erstellen einer ArrayList angeben. Vor dem Hinzufügen einer großen Anzahl von Elementen kann die Anwendung auch den Vorgangsvorgangsvorgang verwenden, um die Kapazität der ArrayList -Instanz zu erhöhen, wodurch die Anzahl der inkrementellen Umverteilungen verringert werden kann.
Beachten Sie, dass diese Implementierung nicht synchron ist. Wenn mehrere Threads gleichzeitig auf eine ArrayList -Instanz zugreifen und mindestens einer der Threads die Liste strukturell ändern, muss sie extern synchronisiert bleiben.
Lassen Sie uns eine Aufzeichnung und eine Zusammenfassung der Java ArrayList machen
öffentliche Klasse ArrayList <E> { / *** Elemente, die die Sammlung speichern** / private transientes Objekt [] elementData; / ** Elementgröße*/ private int Größe;Definieren Sie eine generische Klasse, eine Reihe von Objekten und eine private Variable, um die Anzahl der Elemente in der Sammlung aufzuzeichnen. Im Originaltext befindet sich eine zusätzliche private Variable, und ich weiß nicht, was ich verwenden soll, und der Autor hat keine Erklärung oder Erwähnung. Es ist okay, wenn ich es nicht benutzt habe.
/ ** * Initialisieren Sie gemäß der angegebenen Größe * @param initialCapacity */ public arrayList (int initialCapacity) {Super (); if (initialCapacity <= 0) {// Ausnahme werfen neue illegalArgumentException ("Initialisierungsparameter kann nicht kleiner als 0 sein"); } else {// initialisieren Sie das Array this.elementData = New Object [initialCapacity]; }} / *** Standardinitialisierung* / public arrayList () {this (10); } /*** initialisieren nach einer Sammlungsklasse* @param c Eine Klasse, die die Sammlungsschnittstelle erben muss* /public arrayList (Sammlung <? Erweitert E> c) {// ElementData = C.ToArray (); size = elementData.length; // den Objekttyp konvertieren if (elementData.getClass ()! }} 3 Initialisierungsmethoden, initialisieren Sie das Array gemäß der Standardgröße, initialisieren Sie die angegebene Größe und geben Sie eine Klasse über, die die Sammlungs -Sammlungsschnittstelle für die Initialisierung der Konvertierungszuweisung erbt
/ *** Expansionssammlung* @param mincapacity*/ public void searecapacity (int mincapacity) {/ ** Aktuelle Größe des Arrays*/ int OldCapacity = elementData.length; Wenn (minkapazität> OldCapacity) { /*** Obwohl OldData nicht verwendet wird, handelt es sich um die Speicherverwaltung und die Arrays.Copyof () -Methode nicht mit Thread-safe* olddata bezieht sich auf die elementdata-Variable während des Lebenszyklus von IF, sodass es nicht durch GC* -Kapitur-. Das Zuweisen des Speicher von Speicherelementdata wird daran hindert, angewendet zu werden. * Wenn das Ende verlässt, wenn der alte Zyklus endet und recycelt*/ Objekt OldData [] = elementData; int newcapacity = (OldCapacity * 3)/2 + 1; // 50%+1 erhöhen, wenn (NewCapacity <mincapacity) Newcapacity = Mincapacity; // Verwenden Sie Arrays.copyof, um die Elemente der Sammlung zu kopieren und ein neues Array -ElementData = Arrays.copyof, Newcapacity); }}Dies ist eine Kernmethode. Die Erweiterung des Satzes besteht tatsächlich darin, die Ausdehnung des Arrays und die Größe der Mischlast -Sammlung zu vergleichen, um festzustellen, ob es erweitert werden soll. Die Arrays.Copyof () -Methode wird zur Expansion verwendet.
Der Originaltext hat eine detaillierte Erklärung. Diese Methode kopiert den Inhalt des ersten Parameters in ein neues Array. Die Größe des Arrays ist der zweite Parameter und gibt ein neues Array zurück. Es gibt detaillierte Kommentare zu den Variablen von OldData.
/ *** Überprüfen Sie, ob der Index außerhalb der Grenzen ist }}
Ob eine Einweissuche 1 /** ist
* Element hinzufügen* Fügen Sie das angegebene Element zum Ende der Sammlung hinzu* @Param E hinzugefügt Element* @return*/ public boolean add (e e) {sealecapacity (Größe+1); ElementData [Größe] = e; Größe ++; zurückkehren; }Fügen Sie ein Element hinzu, erweitern Sie zuerst die Kapazität, weisen Sie den Wert und fügen Sie dann das Element ein. Beachten Sie, dass die Feldgröße+1 keine Feldgröße hinzugefügt wird. Hier ist eine arithmetische Operation, daher ist es notwendig, sie später zu erhöhen.
/ *** Element hinzufügen* Element hinzufügen zur angegebenen Position* @param Index angegebenes Indexindex -Indexelement* @param Element* @return*/ public boolean add (int index, E -Element) {rangecheck (index); Sicherungspunkte (Größe+1); // ElementData-Element beginnend mit der Indexposition und Länge von Size-Index, // kopieren Sie in ein neues ElementData-Array aus der Indexposition als Index+1. // Dies bedeutet, dass das derzeit in dieser Position und alle nachfolgende Elemente von einer Position bewegte Element. System.ArrayCopy (ElementData, Index, ElementData, Index+1, Größe-Index); elementData [index] = element; Größe ++; // Element add one return true; }Der Unterschied hier ist System.ArrayCopy (ElementData, Index, ElementData, Index+1, Größe-Index);
Dies ist eine interne Methode von c. Der detaillierte Originaltext hat eine Erklärung, daher werde ich hier nicht darüber sprechen. Dies ist auch der Kern der gesamten ArrayList und auch das interne Implementierungsprinzip von arrays.copyof ()
/*** Fügen Sie alle Elemente hinzu* Fügen Sie alle Elemente in der Sammlung in die Reihenfolge der Elemente hinzu, die vom Iterator der angegebenen Sammlung zurückgegeben wurden. * @param c * @return */ public boolean addall (Sammlung <? Erweitert E> c) {Object [] newElement = c.toarray (); int elementLength = newElement.length; Sicherungstätigkeit (Größe+ElementLength); // Aus dem Index von NewElement 0, ElementLength -Elementen, ElementData -Sagens -System.ArrayCopy (NewElement, 0, ElementData, Größe, ElementLength); Größe+= ElementLength; return elementLength! = 0; }Grundsätzlich führen andere Methoden nur eine andere Verarbeitung gemäß unterschiedlichen Situationen durch, z.
/ *** Geben Sie die Position an, fügen Sie alle Elemente hinzu* @param Index Einfügen Positionsindex* @param c eingefügte Elemente Sammlung* @Return*/ public boolean addall (int index, sammeln <? Erweitert E> c) {if (index> Größe || Index <0) {Wurf neuer IndexoutOnto-BoundSexception ("Index:" + index + "," Größe: " + + Größe); } Object [] newElement = c.toarray (); int elementLength = newElement.length; Sicherungstätigkeit (Größe+ElementLength); int nummoved = Größe-Index; // Beurteilen Sie, ob sich die Insertionsposition in der Mitte des Arrays befindet, wenn (nummoved> 0) {// alle Elemente hinter der Indexeinfügungsposition rückwärts verschieben // Nummoved -Elemente aus dem Indexindexindex in den Index+ElementLength -Position des ElementData -Datensystems einfügen. } // ElementLength in NewElement von 0 zu der Position hinzufügen, wobei der ElementData -Index System startet. Größe += ElementLength; return elementLength! = 0; } / ** * Geben Sie den Wert des Index an * @param index * @param element * @return * / public e set (int index, e element) {rangecheck (index); E oldelement = (e) elementData [index]; elementData [index] = element; OldElement zurückgeben; } / ** * den Wert basierend auf dem Index abrufen * @param index * @return * / public e get (int index) {rangecheck (index); return (e) elementData [index]; } / *** Element entfernen gemäß dem Index* @param index* / public e remove (int index) {rangecheck (index); E oldelement = (e) elementData [index]; / ** Die Anzahl der Elemente nach dem entfernten Index*/ int nummoved = Größe-Index-1; // Wenn es innerhalb des Array -Bereichs bewegt wird, wenn (nummoved> 0) system.ArrayCopy (elementData, Index+1, elementData, Index, numMoved); // ElementData [-Größe] = NULL entfernen; OldElement zurückgeben; } /** * entfernen nach Element * @param obj * @return * /public boolean remove (Object obj) {// ArrayList zulässt null, daher muss die Beurteilung der Beurteilung auch durchgeführt werden, wenn (obj == null) {für (int index = 0; Index <Größe; Index ++) {if (elementData [index] == null) {entfernen) {entfernen); zurückkehren; }}} else {for (int index = 0; index <size; index ++) {if (obj.equals (elementData [index])) {remove (index); zurückkehren; }}} return false; } / *** Elemente im angegebenen Bereich entfernen nach dem Index* @param von iNidEx start* @param toIndex end Rangecheck (toIndex); // die Anzahl der zu bewegenden Elemente intummoved = Größe - nach Index; // Verschieben Sie das Element hinter dem Index auf das INDEX -System. // die Anzahl der zu entfernenden Elemente in Int newSize = size- (toIndex-fromIdex); while (size! = newSize) {elementData [-size] = null; }} / *** Die Array -Kapazität an die tatsächliche Kapazität anpassen* / public void trimToSize () {int länge = elementData.length; if (Größe <leng) {Object [] old = elementData; elementData = arrays.copyof (ElementData, Größe); }} / *** Sammlungselemente in Array* @Return* / public Object [] toArray () {return arrays.copyof (elementData, Größe) umwandeln; } public <t> t [] toArray (t [] a) {if (a.Length <size) {return (t []) arrays.copyof (elementData, Größe, a.getClass ()); } // Das Sammelelement in das Array Asystem.ArrayCopy (ElementData, 0, a, 0, Größe) kopieren; if (a.Length> Größe) {for (int index = Größe; Index <A.Length; Index ++) {a [index] = null; }} return a; } Grundsätzlich geht es darum, das Array zu betreiben und C -Methoden zu verwenden, um Werte zuzuweisen und zu verschieben. Sie können den Originaltext im Detail anzeigen. Der Originaltext gibt außer der privaten Variablen nicht viele Probleme, und der Code kann perfekt ausgeführt werden. Die Schwierigkeit dieser und die Verwendung der alten Variablen in der Erweiterungsmethode sind die beiden Systemmethoden, ArrayCopy und Arrayist.Copy () und die Verwendung der OldData -Variablen in der Erweiterungsmethode. Diese Variable ist wirklich gut. Am Anfang wusste ich nicht, warum ich es so verwendet habe, und ich werde es am Ende des Originaltextes erklären.
Das obige ist eine Beispiele für die Implementierung von Java ArrayList, die Ihnen vom Editor vorgestellt wurde. Ich hoffe, es wird Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht. Der Herausgeber wird Ihnen rechtzeitig antworten. Vielen Dank für Ihre Unterstützung auf der Wulin Network -Website!