Vergleich von Java -Vektor und ArrayList
Heute habe ich die Quellcodes von Vektor und ArrayList untersucht und mein Verständnis dieser beiden Klassen vertieft.
In der List -Schnittstelle sind drei Klassen implementiert: ArrayList, Vector und LinkedList. Ich werde nicht viel über LinkedList sagen, es wird im Allgemeinen verwendet, um die Reihenfolge der Dateneinführung aufrechtzuerhalten.
ArrayList und Vector werden beide mit Arrays implementiert, und es gibt drei Hauptunterschiede:
1. Vektor ist multi-thread und sicher, während ArrayList nicht ist. Dies ist aus dem Quellcode aus zu sehen. Viele Methoden in der Vektorklasse werden durch synchronisiertes modifiziert, was zur Effizienz des Vektors führt, die nicht mit ArrayList verglichen werden können.
2. Beide verwenden lineare, kontinuierliche Raumspeicherelemente, aber wenn der Speicherplatz nicht ausreicht, werden die beiden Klassen unterschiedlich hinzugefügt. Viele Internetnutzer sagen, dass Vector den ursprünglichen Raum verdoppelt und ArrayList den ursprünglichen Raum um 50%erhöht. Tatsächlich ist dies ungefähr das gleiche. Es gibt jedoch noch einige Probleme, die aus dem Quellcode ersichtlich sind und später aus dem Quellcode analysiert werden.
3. Vektor kann den Wachstumsfaktor festlegen, aber ArrayList kann nicht. Als ich mich das zum ersten Mal ansah, verstand ich nicht, was der inkrementelle Faktor war. Ich habe dies jedoch verstanden, indem ich die beiden Quellcodes verglichen habe. Schauen wir uns zunächst die Baumethoden der beiden Klassen an:
ArrayList verfügt über drei Konstruktionsmethoden:
Öffentliche ArrayList (intit initialCapacity) // Erstellen Sie eine leere Liste mit der angegebenen Anfangskapazität. Public ArrayList () // Erstellen Sie eine leere Liste mit einer anfänglichen Kapazität von 10. Public ArrayList (Sammlung <? Erweitert E> C) // Erstellen Sie eine Liste von Elementen, die die angegebene Sammlung enthalten
Der Vektor hat vier Konstruktoren:
öffentlicher Vektor () // Erstellen Sie einen leeren Vektor unter Verwendung der angegebenen Anfangskapazität und Kapazitätsinkrement gleich Null. Öffentlicher Vektor (int initialCapacity) // Erstellen Sie einen leeren Vektor, um die Größe seines internen Datenarrays zu ermitteln, und sein Stermeinstieg der Standardkapazität beträgt Null. öffentlicher Vektor (Sammlung <? Erweitert E> C) // Erstellen Sie einen Vektor, der Elemente im angegebenen Sammlung öffentlicher Vektor (int initialCapacity, int capacityIncrement) enthält // einen leeren Vektor unter Verwendung der angegebenen Anfangskapazität und Kapazitätserhöhungen konstruieren
Vector verfügt über eine mehr Konstruktionsmethode als ArrayList. Das ist richtig, die Baumethode des öffentlichen Vektors (INT initialCapacity, int CapacityIncrement). Kapazitätsinkrement ist das Kapazitätswachstum, der oben genannte Wachstumsfaktor, der in ArrayList nicht verfügbar ist.
Veröffentlichen Sie dann zwei Klassen, um die Quellcodeanalyse hinzuzufügen (JDK1.7 -Version):
// ArrayList -Klasse Quellcode hinzufügen: public boolean add (e e) {sealEcapacityInternal (Größe + 1); // Inkrementiert modcount !! ElementData [Größe ++] = e; zurückkehren; } private void tealecapacityInternal (int mincapacity) {modcount ++; // Überlauf-bewusstes Code // Wenn nach dem Hinzufügen eines Elements die Größe des neuen Containers größer ist als die Kapazität des Containers, kann der Wert nicht gespeichert werden. Der Raum muss erweitert werden, wenn (minkapazität - elementData.length> 0) wachsen (minkapazität); } private void Grow (int mincapacity) {// Überlauf-unbewusster Code int oldCapacity = elementData.length; int newCapacity = OldCapacity + (OldCapacity >> 1); // Der Expansionsraum nimmt um 50% zu (dh 1,5 -fach das Original) Wenn (Newcapacity - Mincapacity <0) // Wenn der Container nach der Erweiterung noch nicht ausreicht, stellen Sie dann nur die Größe des Containers Newcapacity = mincapacity fest; if (newcapacity - max_array_size> 0) // Wenn der erweiterte Container zu groß ist, führen Sie die Hugenkapazität aus. // Hackigkeit liegt normalerweise nahe an der Größe, daher ist dies ein Gewinn: elementData = arrays.copyof (elementData, Newcapacity); } Fügen Sie der Vektorklasse den Quellcode hinzu:
public synchronisierte boolean add (e e) {modcount ++; sealecapacityHelper (elementCount + 1); elementData [elementCount ++] = e; zurückkehren; } private void sealecapacityHelper (int mincapacity) {// Überlauf -unbewusster Code if (mincapacity - elementData.length> 0) wachsen (mincapacity); } private void Grow (int mincapacity) {// Überlauf-unbewusster Code int oldCapacity = elementData.length; int newCapacity = OldCapacity + ((CAPAPYINCREMENT> 0)? CAPAPY INCREMENT: OldCapacity); /** Diese Kapazitätserweiterung erfordert ein Urteilsvermögen: Wenn das Kapazitätsinkrement nicht durch 0 initialisiert wird, dh die Initialisierung des öffentlichen Vektors (intit initialCapacity, int -Kapazitätsinkrement), dann ist die Kapazitätserweiterungskapazität (OldCapacity+CapacityIncrement), was der Wert der ursprünglichen Kapazität ist. Wenn das Kapazitätsinkrement nicht festgelegt ist, ist die Kapazität nach der Ausdehnung (OldCapacity+OldCapacity), was doppelt so hoch ist wie die ursprüngliche Kapazität. **/ if (Newcapacity - Mincapacity <0) NewCapacity = Mincapacity; if (newcapacity - max_array_size> 0) newCapacity = Hugcapacity (mincapacity); elementData = arrays.copyof (ElementData, NewCapacity); }Durch die Analyse sollte es jetzt verständlich sein!
Danke fürs Lesen, ich hoffe, es kann Ihnen helfen. Vielen Dank für Ihre Unterstützung für diese Seite!