Das Innenleben von ArrayList in Java

ArrayList ist eine Klasse im Java Collection Framework, die die List-Schnittstelle implementiert. Es handelt sich um eine lineare Struktur, die jedes Element nacheinander speichert und darauf zugreift. Dies liegt daran, dass intern ein dynamisches Array zum Speichern seiner Elemente verwendet wird. Wie Arrays ermöglicht es auch die Speicherung doppelter Elemente. Ein dynamisches Array bezieht sich hier auf ein Array, das je nach Bedarf vergrößert und verkleinert werden kann. In diesem Artikel untersuchen wir das Innenleben einer ArrayList, um zu zeigen, wie sie ihre Elemente speichert und ihre Größe während des Betriebs ändert.

Wie funktioniert ArrayList intern in Java?

Die meisten von uns wissen, dass Standard-Arrays eine feste Länge haben. Sobald Arrays deklariert und initialisiert sind, können sie weder wachsen noch schrumpfen, was bedeutet, dass wir nach Angabe ihrer Größe keine weiteren Elemente hinzufügen können. In einigen Einzelfällen kennt der Entwickler die erforderliche Array-Größe jedoch möglicherweise erst zur Laufzeit. In diesem Fall ist ArrayList eine bessere Alternative zu Array, das die Anzahl der Elemente dynamisch erhöhen oder verringern kann.

Konstruktor von ArrayList

Um ArrayList in unserem Programm zu verwenden, müssen wir zunächst eine Instanz der ArrayList-Klasse erstellen. Zu diesem Zweck stellt Java drei verschiedene Konstruktoren zur Verfügung, die im Folgenden aufgeführt sind:

• ArrayList(): Es wird eine leere ArrayList erstellt.

• ArrayList(intcapacityInitial): In diesem Konstruktor können wir die Anfangskapazität der Anzahl der Elemente übergeben, die die ArrayList aufnehmen kann. Sobald die Anzahl der Elemente die anfängliche Kapazität erreicht, wird die Kapazität automatisch erhöht.

• ArrayList(Collection CollectionName): Wir können diesen Konstruktor auch verwenden, um eine ArrayList aus einer anderen Sammlung zu erstellen.

Warum ist ArrayList dynamisch?

Wenn wir mithilfe der integrierten Methode „add()“ ein Element zu ArrayList hinzufügen, prüft diese zunächst, ob im Array genügend Platz zum Speichern des neuen Elements vorhanden ist. Falls vorhanden, weist es das neue Element dem nächsten verfügbaren Index im Array zu. Wenn nicht genügend Platz für das neue Element vorhanden ist, erstellt es ein neues Array mit einer größeren Kapazität, normalerweise dem 1,5-fachen der aktuellen Kapazität, kopiert dann alle vorhandenen Elemente aus dem alten Array in das neue Array und weist die neuen Elemente dem nächsten zu verfügbaren Index eines Elements in das neu erstellte Array.

Wenn wir mit der integrierten Methode „remove()“ ein Element aus einer ArrayList entfernen, werden alle Elemente nach dem entfernten Element um einen Index nach links verschoben. Das Array wird jedoch nicht sofort verkleinert, es kann jedoch zu einer späteren Verkleinerung kommen, wenn die Größe im Vergleich zur Kapazität zu klein ist.

Lassen Sie uns einige Beispiele besprechen, um die oben besprochenen Punkte besser zu verstehen.

Beispiel 1

Das folgende Beispiel zeigt, wie Elemente einer ArrayList in Java erstellt und gedruckt werden.

import java.util.*;
public class Example1 {
   public static void main(String[] args) {
	   // Creating arraylist 
      ArrayList<Integer> araylist = new ArrayList<Integer>();
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>// Adding elements in arraylist<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(8);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(5);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(2);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(9);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(2);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(4);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(9);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(7);
<span style="font-size: 11.4844px;">      </span>System.out.println("List of elements: " + araylist);
   }
}

Ausgabe

List of elements: [8, 5, 2, 9, 2, 4, 9, 7]

Beispiel 2

Im folgenden Beispiel erstellen wir eine ArrayList mit einer anfänglichen Kapazität und versuchen, Elemente über die angegebene Kapazität hinaus hinzuzufügen, um zu zeigen, dass eine ArrayList dynamisch wachsen kann.

import java.util.*;
public class Example2 {
   public static void main(String[] args) {
      // Creating arraylist with initial capacity of 5
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>ArrayList<Integer> araylist = new ArrayList<Integer>(5);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>// Adding elements in arraylist
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(80); // 1
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(15); // 2
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(23); // 3
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(9); // 4
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(12); // 5
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>// adding more elements 
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(14);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(91);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>araylist.add(74);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>System.out.println("List of elements: " + araylist);
   }
}

Ausgabe

List of elements: [80, 15, 23, 9, 12, 14, 91, 74]

Beispiel 3

In diesem Beispiel erstellen wir eine ArrayList aus einem HashSet, um zu demonstrieren, dass Elemente einer Menge zu einer ArrayList hinzugefügt werden können. Intern prüft es zunächst die Größe der übergebenen Sammlung und speichert dann die Elemente in der angegebenen ArrayList mithilfe der Methode „Arrays.copyOf()“.

import java.util.*;
public class Example3 {
   public static void main(String[] args) {
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>// Creating a Set 
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>HashSet<Integer> setH = new HashSet<>();
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>// Adding elements in the Set
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>setH.add(80); 
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>setH.add(15); 
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>setH.add(23); 
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>setH.add(9); 
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>setH.add(12); 
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>setH.add(14);<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>setH.add(91);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>setH.add(74);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>// Passing the Set to the ArrayList
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>ArrayList<Integer> araylist = new ArrayList<>(setH);
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>// printing the result
<span style="font-size: 0.875em; font-weight: var(--bs-body-font-weight);">      </span>System.out.println("List of elements: " + araylist);
   }
}

Ausgabe

List of elements: [80, 23, 9, 74, 91, 12, 14, 15]

Fazit

Wir haben diesen Artikel mit der Definition von ArrayList begonnen und im nächsten Abschnitt besprechen wir die Funktionsweise. ArrayList ist ein in der Größe veränderbares Array mit einer Standardkapazität von 10, die erhöht werden kann, wenn wir weitere Elemente hinzufügen. Wir können die Anfangskapazität auch beim Erstellen der ArrayList im Konstruktor angeben.

Das obige ist der detaillierte Inhalt vonDas Innenleben von ArrayList in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!