Detaillierte Analyse der ArrayList-Klasse [Teil 1]

In diesem Artikel werfen wir einen detaillierten Blick auf die ArrayList-Klasse aus dem Collections Framework, die vielleicht am einfachsten zu verstehen ist, da sie auf einem regulären Array basiert. Im Vorstellungsgespräch wird Ihnen mit ziemlicher Sicherheit eine Frage zu dieser Klasse und ihrer Implementierung in Java gestellt. Im zweiten Teil analysieren wir die verbleibenden Methoden und schreiben unsere eigene Implementierung eines dynamischen Arrays für Zahlen. Die ArrayList-Klasse erbt von der AbstractList-Klasse und implementiert die folgenden Schnittstellen: List, RandomAccess, Cloneable, Serializable. Eine detaillierte Analyse der ArrayList-Klasse [Teil 2] Die ArrayList-Klasse unterstützt dynamische Arrays, die nach Bedarf erweitert werden können. Seine Notwendigkeit und Wirksamkeit erklärt sich aus der Tatsache, dass ein reguläres Array eine feste Länge hat: Sobald es erstellt wurde, kann es weder wachsen noch schrumpfen, was zu Einschränkungen führt, wenn nicht bekannt ist, wie groß das Array sein wird. Im Wesentlichen ist die ArrayList-Klasse ein Listenarray variabler Länge von Objektreferenzen. Es ist wichtig zu verstehen, dass die Größe (Anzahl der Zellen) des internen Arrays nicht automatisch abnimmt, wenn Elemente daraus entfernt werden. Tatsächlich sizewird der Wert der Variablen, der die Anzahl der tatsächlich im Array vorhandenen Elemente angibt, verringert. Nehmen wir an, wir erstellen ein neues Objekt der ArrayList-Klasse und fügen ihm 5 Elemente hinzu. Standardmäßig wird ein Array mit 10 Elementen erstellt. In diesem Fall beträgt die sogenannte Kapazität (Größe/Volumen) unseres Objekts 10, der Wert der Variablen sizebeträgt jedoch fünf. Und wenn wir Elemente löschen, sehen wir Änderungen im Wert der Variablen size, da wir .lengthnicht auf das interne Array der ArrayList-Klasse zugreifen und dessen Länge ermitteln können. Die Größe kann mit einer zusätzlichen Methode reduziert werden trimToSize(), die weiter unten erläutert wird. Schauen wir uns die Klassenfelder an.

• Feld, das für die Standardlautstärke des dynamischen Arrays verantwortlich ist:

  private static final int DEFAULT_CAPACITY = 10

  Beim Erstellen eines neuen Objekts new ArrayList<>() (ein parameterloser Konstruktor) wird darin ein Array mit 10 Elementen erstellt.

• Ein Feld, in dem alle Elemente der Sammlung gespeichert werden:

  transient Object[] elementData

  Mit einem Schlüsselwort markiert transient– das Feld wird bei Verwendung des Standard-Serialisierungsalgorithmus nicht in den Bytestream geschrieben. Es ist erwähnenswert, dass das Feld nicht mit dem Schlüsselwort markiert ist private, dies wurde jedoch getan, um den Zugriff auf dieses Feld aus verschachtelten Klassen (z. B. SubList) zu erleichtern.

• Ein Zählerfeld, das die Anzahl der tatsächlich im Array enthaltenen Elemente speichert:

  private int size

  Der Wert wird erhöht/dekrementiert, wenn Vorgänge wie Einfügen und Löschen ausgeführt werden.

Es gibt drei weitere Felder in der Klasse, aber im Wesentlichen handelt es sich um zusätzliche Felder, sodass es keinen Sinn macht, sie zu berücksichtigen. Die Klasse hat drei Konstruktoren:

1. public ArrayList()– erstellt ein leeres Listenarray mit 10 Elementen;
2. public ArrayList(Collection < ? extends E > c)– erstellt ein Listenarray, das mit Elementen aus der übergebenen Sammlung initialisiert wird (wenn wir eine neue ArrayList basierend auf einer Sammlung erstellen möchten);
3. public ArrayList(int initialCapacity)– erstellt ein Listenarray mit einer Anfangskapazität. Wenn der übergebene Parameter initialCapacity größer als 0 ist, wird ein Array der angegebenen Größe erstellt (dem internen Feld elementData wird ein Link zu einem neuen Array vom Typ Objekt der Größe initialCapacity zugewiesen). Wenn der Parameter 0 ist, wird ein leeres Array erstellt. Wenn der angegebene Parameter kleiner als 0 ist, wird eine IllegalArgumentException ausgelöst.

Ein Objekt erstellen

List < String> list = new ArrayList<>();

Das neu erstellte Objekt listenthält Eigenschaften (Felder) elementDataund size. Ein Wertspeicher elementDataist nichts anderes als ein Array eines bestimmten Typs (angegeben in generisch – <>), in unserem Fall String[]. Wenn ein Konstruktor ohne Parameter aufgerufen wird, wird standardmäßig ein Array mit 10 Elementen vom Typ Object erstellt (natürlich mit Umwandlung in den Typ). Hinzufügen von Elementen Das klassische Hinzufügen von Elementen zu einem Listenarray erfolgt mithilfe überladener Varianten von add().

public boolean add(E элемент)

Nun, fügen wir hinzu: list.add("0"); Innerhalb dieser Methode wird eine überladene Version der Methode add()aufgerufen, markiert als private, die wiederum drei Parameter als Eingabe akzeptiert: das hinzuzufügende Element, das interne Array und seine Größe. Bei der privaten Methode erfolgt eine Prüfung: Wenn der übergebene Größenparameter gleich der Länge des internen Arrays ist (d. h. das Array ist voll), dann wird dem Array das Ergebnis der Methode grow(int minCapacity)(der aktuelle Wert des Feldes) zugewiesen (Größe + 1 wird an die Methode übergeben, da das hinzugefügte Element berücksichtigt werden muss), in dem dem internen Array ein Link zu dem neu erstellten Array zugewiesen wird, das durch Kopieren der Elemente des ursprünglichen Arrays erhalten wird:

Arrays.copyOf(elementData, newCapacity(minCapacity))

Als zweiten Parameter der Methode copyOfgeben wir das Ergebnis der Methode an newCapacity(int minCapacity), innerhalb dessen die neue Array-Größe berechnet wird. Sie wird mit der folgenden Formel berechnet: int newCapacity = oldCapacity + (oldCapacity >> 1) Für ein Array mit der Standardgröße gilt Folgendes: >> 1– Bitweise Verschiebung um eins nach rechts (ein Operator, der eine Zahl auf die Hälfte reduziert). Im Wesentlichen bedeutet dies eine Division durch 2 hoch 1. Es stellt sich heraus, dass wir 10 durch 2 dividieren und 10 addieren. Insgesamt beträgt die neue Kapazität des Arrays 15, aber da wir das 11. Element addieren, ergibt sich 15 + 1 = 16. Kehren wir zu unserer Liste zurück und nehmen an, dass wir ihr bereits 10 Elemente hinzugefügt haben, und versuchen, 11 hinzuzufügen. Die Überprüfung zeigt, dass im Array kein Platz vorhanden ist. Dementsprechend wird ein neues Array erstellt und aufgerufen Arrays.copyOf, das intern die Systemmethode verwendet System.arraycopy(). Oder hier ist ein klares Beispiel aus einem Artikel über JavaRush: Nach all diesen Prüfungen und gegebenenfalls der Vergrößerung des Arrays add()wird in einer privaten Methode ein neues Element am Ende des Arrays hinzugefügt und der aktuelle Parameter sizeum eins erhöht . Das alte Array wird anschließend vom Garbage Collector verarbeitet. So funktioniert ein dynamisches Array: Wenn wir Elemente hinzufügen, prüfen wir, ob darin noch Platz ist. Wenn Platz vorhanden ist, fügen wir das Element einfach am Ende des Arrays hinzu. Mit dem Ende ist nicht die letzte Zelle im Array gemeint, sondern die Zelle, die dem Wert entspricht size. Wir haben das erste Element zum Array hinzugefügt; es wird in der Zelle mit dem Index [0] platziert. Der Feldwert sizehat sich um eins erhöht und ist = 1. Wir fügen das nächste Element hinzu: Wir sehen das size = 1, entsprechend platzieren wir das Element in der Zelle mit dem Index [1] und so weiter. Es gibt eine überladene Version der Methode mit zwei Parametern:

public void add(int index, E element)

Wir können die Position (Index) der Zelle angeben, in der wir das Element hinzufügen möchten. Zunächst wird die Richtigkeit des angegebenen Indexwerts überprüft, da die Möglichkeit besteht, dass ein falscher Index angegeben wird, der auf eine Zelle zeigt, in der nichts ist oder die einfach nicht existiert. Indizes prüfen: index > size || index < 0– Wenn der angegebene Index größer als die aktuelle Größe des Arrays oder kleiner als 0 ist, wird eine Ausnahme ausgelöst IndexOutOfBoundsException. Anschließend wird bei Bedarf die Größe des Arrays erhöht, ähnlich wie im obigen Beispiel. Sie haben wahrscheinlich schon gehört, dass bei Add-/Remove-Vorgängen in einem Array etwas irgendwo verschoben wird (entweder nach rechts oder nach links). Die Verschiebung erfolgt also durch Kopieren des Arrays: System.arraycopy(elementData, index, elementData, index + 1, s - index); Alle Elemente, die sich rechts vom angegebenen Index befinden, werden um eine Position nach rechts verschoben (Index+1). Und erst danach wird am angegebenen Index ein neues Element zum internen Array hinzugefügt. Da wir einen Teil des Arrays um eins nach rechts verschoben haben (es wird kein neues Array erstellt), ist die benötigte Zelle zum Schreiben frei. Die Verknüpfung zum alten Array wird gelöscht und in Zukunft vom Garbage Collector übernommen. Fügen Sie „maserati“ in die bereits belegte Zelle [3] ein: Wenn also ein Element am Index eingefügt wird und im Array keine freien Plätze vorhanden sind, System.arraycopy()erfolgt der Aufruf zweimal: der erste in grow(), der zweite in der Methode selbst add(index, value), was sich deutlich auf die Geschwindigkeit des gesamten Additionsvorgangs auswirkt. Wenn also ein weiteres Element in das interne Array geschrieben werden muss, dort aber kein Platz vorhanden ist, geschieht Folgendes in der ArrayList:

• Es wird ein neues Array mit einer Größe erstellt, die 1,5-mal größer ist als das Original, plus einem Element.
• Alle Elemente aus dem alten Array werden in das neue Array kopiert
• Das neue Array wird in der internen Variablen des ArrayList-Objekts gespeichert und das alte Array wird als Müll deklariert.

Die Kapazität von Objekten vom Typ ArrayList kann manuell mit der Methode erhöht werden:

public void ensureCapacity(int minCapacity)

Indem Sie die Array-Kapazität im Voraus erhöhen, können Sie später eine zusätzliche Umverteilung des Arbeitsspeichers vermeiden. Die Methode vergrößert das interne Array, um die Anzahl der an übergebenen Elemente aufzunehmen minCapacity. Die Methode ensureCapacity()wirkt sich nicht auf das Feld aus size, sondern auf die capacityGröße des internen Arrays. Ich betone noch einmal, dass sizebeides capacityverschiedene Dinge sind und es sehr wichtig ist, sie nicht zu verwechseln! Wenn Sie die Größe des zugrunde liegenden Arrays, aus dem die ArrayList erstellt wird, auf die aktuelle Anzahl der tatsächlich gespeicherten Elemente reduzieren möchten, sollten Sie die aufrufen trimToSize(). Nach dem Entfernen von Elementen aus der Sammlung size()wird die Anzahl der tatsächlich vorhandenen Elemente angezeigt und capacitynicht verringert! Angenommen: Wir haben 100 Elemente eingegeben, die ersten 50 gelöscht, sizees wird gleich 50 und capacitybleibt also 100. Um und zu reduzieren capacity, müssen wir die Methode verwenden trimToSize(), die unsere gesamte Kapazität an die aktuelle Größe anpasst. Wie passt es? Kopiert unser Array, sodass keine leeren Zellen mehr übrig sind (die Länge des neuen Arrays entspricht einfach der Feldgröße). Sie können unserer Sammlung auch Elemente hinzufügen, indem Sie die verwenden addAll.

public boolean addAll(Collection< ? extends E> c)
public boolean addAll(int index, Collection< ? extends E> collection);

Mit der ersten Option können Sie alle Elemente aus der im Methodenparameter angegebenen Sammlung (z. B. ein anderes Blatt) zur ursprünglichen Sammlung (am Ende einfügen) hinzufügen, für die der Methodenaufruf durchgeführt wurde. Die übergebene Sammlung (es kann auch eine Menge sein) wird mithilfe von in ein Array umgewandelt toArray(). Selbstverständlich erfolgt der Additionsvorgang auch durch Kopieren. collectionDie zweite besteht darin , alle Elemente beginnend mit index zur Liste hinzuzufügen index. In diesem Fall werden alle Elemente um die Anzahl der Elemente in der Liste nach rechts verschoben collection. Elemente entfernen Schauen wir uns zunächst die klassischen Möglichkeiten zum Entfernen von Elementen aus einer ArrayList an.

public E remove(int index)

Führt das Löschen nach Index durch und verschiebt alle nachfolgenden Elemente (nach dem Element am angegebenen Index) nach links, wodurch die „Lücken“ geschlossen werden. Außerdem wird das gelöschte Element (E) zurückgegeben, das vor dem Löschen zuvor in eine zusätzliche Variable geschrieben wurde, deren Wert wir als Ergebnis des Methodenaufrufs erhalten. Um zu verstehen, was E ist, müssen Sie sich mit den sogenannten generischen Typen vertraut machen. Die Notation E gibt an, dass die Methode den Datentyp zurückgibt, der beim Erstellen des ArrayList-Objekts angegeben wurde (denken Sie daran: List <String> list, entsprechend wird E in diesem Fall „ersetzt“ String). Für ein allgemeines Verständnis empfehle ich Ihnen dringend, sich mit generischen Typen vertraut zu machen. Die Korrektheit des eingegebenen Index wird überprüft und dann innerhalb der Methode das Element nicht vollständig gelöscht, sondern eine private Methode aufgerufen fastRemove(Object[] es, int i), in der die Löschung bereits erfolgt. Wir übergeben unser Array und den angegebenen Index als Eingabe an die Methode. Die Elemente werden mit kopiert System.arraycopy(), die Größe des Arrays reduziert und dann weisen wir dem letzten Element null zu. Es ist erwähnenswert, dass kein neues Array erstellt wird: System.arraycopy(es, i + 1, es, i, size - 1 - i); Der Teil, der sich rechts von der Position unter dem angegebenen Index (i+1) befindet, wird in unser ursprüngliches Array (es) kopiert und beginnt an genau dieser Position (i) wo sich das zu löschende Element befand. Somit führten wir eine Verschiebung nach links durch und löschten unser Element. Versuchen wir, das Element bei Index 3 aus dem folgenden Array zu entfernen: Betrachten wir die zweite Version der Methode:

public boolean remove(Object o)

Die Methode entfernt das übergebene Element aus der Liste o, genauer gesagt das Objekt am angegebenen Link. Wenn ein Element in der Liste vorhanden ist, wird es entfernt und alle Elemente werden nach links verschoben. Wenn das Element in der Liste vorhanden ist und erfolgreich entfernt wurde, gibt die Methode true zurück, andernfalls false. Ähnlich wie bei der Option beim Löschen nach Index wird die Methode aufgerufen fastRemove(), bei der genau die gleichen Aktionen ausgeführt werden. Der Unterschied besteht darin, dass die Methode zusätzlich über eine Methode der Object-Klasse remove(Object o)nach dem gewünschten Objekt sucht . equals()Beim Entfernen nach Wert durchläuft die Schleife alle Elemente der Liste, bis eine Übereinstimmung gefunden wird. Nur das erste gefundene Element wird gelöscht. Fassen wir zusammen: Beim Löschen von Elementen aus einem dynamischen Array bleiben keine Lücken wie in einem regulären Array übrig (die gelöschte Zelle wird nicht leer sein). Alle nachfolgenden Elemente (die sich rechts vom Index befanden) werden um eine Position nach links verschoben. Es gibt mehrere zusätzliche Methoden, mit denen Elemente in unterschiedlichem Ausmaß aus der Liste entfernt werden können. Schauen wir sie uns kurz an. Aufräumen unserer Sammlung:

public void clear()

Eine einfache Schleife fordurchläuft alle Elemente eines Arrays und weist jedem Element Null zu. Sie können die Elemente aus unserer Sammlung entfernen, die in einer anderen übertragenen Sammlung enthalten sind, wie folgt:

public boolean removeAll(Collection< ?> c)

Wenn Sie mehrere Elemente entfernen müssen, sollten Sie dies wahrscheinlich nicht in einer bedingten Schleife tun: Es ist bequemer und sicherer, die Methode zu verwenden removeAll(). Es akzeptiert eine Sammlung von Elementen, die aus der Liste entfernt werden. Die Sammlung muss Elemente desselben Typs enthalten, die in der Zielliste gespeichert sind. Sonst wird es weggeworfen ClassCastException. Die Methode gibt true zurück, wenn die Liste durch den Methodenaufruf geändert wurde. Entfernt Elemente, die nicht zur übergebenen Sammlung gehören:

public boolean retainAll(Collection< ?> c)

Nehmen wir an, wir haben eine Sammlung:

List< String> listFirst = new ArrayList<>();
listFirst.add("White");
listFirst.add("Black");
listFirst.add("Red");

Und der zweite:

List< String> listSecond = new ArrayList<>();
listSecond.add("Green");
listSecond.add("Red");
listSecond.add("White");

Dann bleibt nach listSecond.retainAll(listFirst)in übrig :listSecond

"White"
"Red"

Da „Grün“ entfernt wurde, steht das nicht in listFirst. Aber danach bleibt listSecond.removeAll(listFirst)es :listSecond

"Green"
Удалoderсь все элементы, которые есть в listFirst.

Gehört nicht zur übergebenen Sammlung – bedeutet, dass Sie Elemente, die nicht in der übergebenen Sammlung enthalten sind, aus der ersten Sammlung (auf die die Methode angewendet wird) entfernen müssen. Gehört zur übertragenen Sammlung. Wenn also sowohl in der ersten als auch in der zweiten (übertragenen) Sammlung ein Element vorhanden ist, wird das Duplikat der ersten zerstört.

protected void removeRange(int fromIndex, int toIndex)

Entfernt alle Elemente aus der Liste, die zwischen dem angegebenen Anfangsindex (einschließlich) und dem angegebenen Endindex (nicht einschließlich) liegen. Es ist zu beachten, dass die Methode nicht direkt für ein ArrayList-Objekt aufgerufen werden kann. Um es zu verwenden, müssen Sie von erben AbstractList/ArrayList. Die Methode wird auch von einer anderen Methode verwendet (subList, die später besprochen wird).

public boolean removeIf(Predicate< ? super E> filter)

Entfernt Elemente aus einer Sammlung basierend auf einem bestimmten Prädikat. Das Prädikat selbst ist eine bestimmte Funktion/einen bestimmten Algorithmus/eine bestimmte Bedingung, auf deren Grundlage ein oder mehrere Elemente, die einer bestimmten Bedingung entsprechen, entfernt werden. Predicate— eine funktionale Schnittstelle (enthält nur eine Methode, kann also als Lambda verwendet werden), funktioniert nach dem Prinzip „einen Parameter empfangen – booleschen Wert zurückgegeben“. Im Wesentlichen überschreibt die Methode die Implementierung der Schnittstelle Collectionund implementiert die folgende „Strategie“: Sie durchläuft die Elemente und markiert diejenigen, die mit unserem übereinstimmen Predicate; Anschließend wird es ein zweites Mal durchlaufen, um die Elemente zu entfernen (und zu verschieben), die in der ersten Iteration markiert wurden. Lassen Sie uns eine Schnittstelle implementieren, Predicatedie „true“ zurückgibt, wenn zwei Objekte gleich sind:

class SamplePredicate< T> implements Predicate< T>{
  T varc1;
  public boolean test(T varc){
     if(varc1.equals(varc)){
       return true;
  }
  return false;
  }
}

Erstellen wir in einer anderen Klasse eine ArrayList aus Stringeinem Objekt unserer Klasse, das Folgendes implementiert Predicate:

ArrayList< String> color_list = new ArrayList<> ();
SamplePredicate< String> filter = new SamplePredicate<> ();

varc1Schreiben wir den Wert „Weiß“ in die Variable :

filter.varc1 = "White";

Fügen wir der Liste ein paar Zeilen hinzu:

color_list.add("White");
color_list.add("Black");
color_list.add("Red");
color_list.add("White");
color_list.add("Yellow");
color_list.add("White");

Führen wir die Methode auf der Liste aus removeIf, an die wir unser Objekt mit der Bedingung übergeben:

color_list.removeIf(filter);

Dadurch werden alle Zeilen mit dem Wert „Weiß“ aus der Liste entfernt, da unser „Prädikat“ sie auf Gleichheit vergleicht. Endgültige Liste: [Schwarz, Rot, Gelb]. Elemente austauschen

public E set(int index, E element)

Ersetzt das Element an der angegebenen Position indexdurch das übergebene element. Der Index muss außerdem größer als Null und kleiner als der Index des letzten Elements sein, sonst wird eine Ausnahme ausgelöst IndexOutOfBoundsException. Es entstehen keine Kopien des internen Arrays. Anstelle des Elements am angegebenen Index wird einfach ein neues Element eingefügt, d. h. den Wert überschreiben.

public void replaceAll(UnaryOperator<e> operator)

Ändert alle Elemente der Sammlung (möglich mit einer Bedingung). Wird meist in Kombination mit Lambdas oder einer anonymen Klasse verwendet (aber der Übersichtlichkeit halber verwenden wir im Beispiel einfach eine Klasse, die die Schnittstelle implementiert), die die Schnittstelle implementiert UnaryOperatorund ihre Methoden definiert. Lassen Sie uns die Schnittstelle implementieren:

class MyOperator< T> implements UnaryOperator< T>{
   T varc1;
   public T apply(T varc){
     return varc1;
  }
}

Erstellen wir in einer anderen Klasse eine ArrayList aus Stringeinem Objekt unserer Klasse, das Folgendes implementiert UnaryOperator:

ArrayList< String> color_list = new ArrayList<> ();
MyOperator< String> operator = new MyOperator<> ();

varc1Schreiben wir den Wert „Weiß“ in die Variable :

operator.varc1 = "White";

Fügen wir der Liste ein paar Zeilen hinzu:

color_list.add("White");
color_list.add("Black");
color_list.add("Red");
color_list.add("White");
color_list.add("Yellow");
color_list.add("White");

Führen wir eine Methode auf der Liste aus, replaceAllan die wir unser Objekt übergeben operator:

color_list.replaceAll(operator);

Infolgedessen wurden alle Werte in der Liste durch „Weiß“ ersetzt: [Weiß, Weiß, Weiß, Weiß, Weiß, Weiß]. Und so können Sie beispielsweise alle Leerzeichen aus den Strings entfernen, die in der Sammlung sind:

ArrayList< String> list = new ArrayList<>(Arrays.asList("A   ", "  B  ", "C"));
list.replaceAll(String::trim);

Andere Methoden: Sie können das ArrayList-Listen-Array mit der folgenden Methode in ein reguläres Array konvertieren:

public Object[] toArray()

oder

public < T> T[] toArray(T[] a)

- Hier wird der Typ des zurückgegebenen Arrays bestimmt. runtime Diese Methode ermöglicht:

1. einige Vorgänge beschleunigen;
2. Übergeben Sie ein Array als Parameter an eine Methode, die nicht überladen ist, um die Sammlung direkt zu akzeptieren.
3. Integration von neuem sammlungsbasiertem Code in Legacy-Code, der keine Sammlungen erkennt.

Gibt ein Kopierobjekt des Arrays zurück:

public Object clone()

Bitte beachten Sie, dass die Methode clone()den Objekttyp zurückgibt, sodass Sie nach dem Aufruf eine Umwandlung in die erforderliche Klasse durchführen müssen. Durch das Klonen wird ein neues unabhängiges Objekt erstellt. Überprüfen Sie die Sammlung auf das Vorhandensein eines Objekts:

public boolean contains(Object o)

Prüft, ob ein Objekt in der Liste vorhanden ist (intern mit der Methode equal der Object-Klasse, d. h. vergleicht Referenzen) und gibt je nach Ergebnis true/false zurück. Zusätzlich zu den üblichen Schleifen können Sie eine Sammlung durchlaufen (auf jedes Element zugreifen und eine Aktion ausführen), indem Sie Folgendes verwenden:

public void forEach(Consumer< ? super E> action)

So können wir unsere Liste anzeigen:

List< Integer> numbers = new ArrayList<>(Arrays.asList(10, 20, 50, 100, -5));
numbers.forEach((number)-> System.out.println(number));

Ohne Lambdas zu verwenden, müssen Sie eine anonyme Klasse verwenden und die acceptSchnittstellenmethode überschreiben Consumer:

numbers.forEach(new Consumer< Integer>() {
  @Override
   public void accept(Integer integer) {
      System.out.println(integer);
          }
});

Holen Sie sich ein Element anhand seines Index:

public E get(int index)

Wird für den wahlfreien Zugriff auf Sammlungselemente verwendet. Gibt das Element zurück, das sich in der Liste am angegebenen Index befindet. Wenn index < 0oder index >=die maximale Anzahl von Elementen in der Liste ist, wird eine Ausnahme ausgelöst IndexOutOfBoundsException. Dies ist die grundlegende Methode zum Abrufen eines Elements aus einer Liste. Die Zeit zum Abrufen eines Elements anhand des Index ist unabhängig von der Größe der ArrayList immer gleich, da auf eine bestimmte Array-Zelle zugegriffen wird. Suchen von Indizes für bestimmte Objekte:

public int indexOf(Object o);
public int lastIndexOf(Object o);

Die Methoden geben den Index des ersten (wenn das angegebene Objekt zum ersten Mal angetroffen wird) oder letzten Vorkommens (wenn das angegebene Objekt zum letzten Mal angetroffen wird) Element in der Liste zurück. Wenn das Element nicht in der Liste vorhanden ist, geben die Methoden -1 zurück. Überprüfen Sie die Sammlung auf Elemente:

public boolean isEmpty();

Die Methode gibt true zurück, wenn die Liste leer ist (prüft, ob das Feld gleich ist size 0), andernfalls false. Wenn die Liste nur Nullelemente enthält, gibt die Methode false zurück. Mit anderen Worten: Auch Nullelemente werden von dieser Methode berücksichtigt. Ermitteln Sie die Anzahl der Elemente in einer Liste:

public int size();

Gibt die Anzahl der Elemente in der Liste zurück (Größenfeldwerte). Die Anzahl der Elemente kann von der Listenkapazität (Kapazität) abweichen. Holen Sie sich einen Iterator für eine Liste:

public Iterator< E> iterator();

Gibt einen Iterator für eine Liste zur späteren Verwendung in einer Schleife oder einer anderen Verarbeitung zurück. Der Iterator implementiert Fail-Fast-Verhalten. Wenn es die Sammlung durchläuft und einige Änderungen daran feststellt (die nicht mit den Iteratormethoden erhalten wurden), löst es sofort eine Ausnahme aus ConcurrentModificationException. Der Iterator hat etwas namens modification count. Wenn der Iterator die Sammlung nach jedem durchläuft next/hasNext/remove, überprüft er diesen Zähler. Wenn es nicht mit dem übereinstimmt, was der Iterator erwartet hat, wird eine Ausnahme ausgelöst. Ich werde Iteratoren hier nicht im Detail betrachten.

public ListIterator< E> listIterator() и public ListIterator< E> listIterator(int index)

Gibt einen Listeniterator für eine Liste zur späteren Verwendung in einer Schleife oder einer anderen Verarbeitung zurück. Die Schnittstelle ListIteratorerweitert die Schnittstelle Iteratorfür die bidirektionale Durchquerung der Liste und die Änderung ihrer Elemente. In der überladenen Version können Sie den Index übergeben, ab dem die „Traversierung“ beginnt. Der Index bezeichnet in diesem Fall das erste Element, ab dem die Methode ihre Arbeit beginnt next(), und wenn die Methode aufgerufen wird, previous()beginnt der Durchlauf ab dem Element unter dem Index „übergebener Index - 1“.

public Spliterator <E> spliterator()

Java 8 führt einen neuen Typ eines Late-Binding- und Fail-Fast-Iterators ein, der als Trennzeichen-Iterator bezeichnet wird. Mit Separator-Iteratoren können Sie eine Folge von Elementen durchlaufen, sie werden jedoch auf andere Weise verwendet. Das wichtigste Merkmal der Spliterator- Schnittstelle ist ihre Fähigkeit, die parallele Iteration einzelner Teile einer Folge von Elementen und damit die parallele Programmierung zu unterstützen.