Java LinkedList (LinkedList)

In diesem Tutorial werden wir die LinkedList-Klasse durch viele Beispiele detailliert kennenlernen.

Die LinkedList-Klasse der Java Collection-Framework bietet Funktionen der Listen-Datenstruktur.

Von LinkedList implementierte Schnittstelle

• Java List Schnittstelle

• Java Queue-Schnittstelle

• Java Deque Schnittstelle

LinkedList-Implementierung in Java

Die Java LinkedList-Klasse bietet eine Implementierung von Doubly-Linked-Listen.

Jedes Element in der Liste wird alsKnoten. Es enthält3Felder:

• Prev - Speichert die Adresse des vorherigen Elements in der Liste. Das erste Element ist null.

• Next - Speichert die Adresse des nächsten Elements in der Liste. Der letzte Element ist null.

• Daten - Speichert tatsächliche Daten.

Die Elemente der Liste sind nicht in der Reihenfolge gespeichert. Im Gegenteil, sie sind verteilt und durch Verknüpfungen (Prev und Next) verbunden.

Hierbei enthält die Linkliste3Elemente.

• Dog - Das erste Element wird null als vorherige Adresse und die Adresse von Cat als nächste Adresse

• Cat - Das zweite Element wird die Adresse von Dog als vorherige Adresse und die Adresse von Cow als nächste Adresse

• Cow - Der letzte Element wird die Adresse von Cat als vorherige Adresse und null als nächstes Element

Erstellen Sie eine LinkedList

Dies ist die Methode, wie wir in Java Linklisten erstellen:

LinkedList<Type> linkedList = new LinkedList<>();

Hierbei stellt Type den Typ der Linkliste dar. Zum Beispiel,

//Eine Liste von Integers erstellen
LinkedList<Integer> linkedList = new LinkedList<>();
//Eine Liste von Strings erstellen
LinkedList<String> linkedList = new LinkedList<>();

LinkedList mit Schnittstellen erstellen

Lassen Sie uns ein Beispiel nennen.

List<String> animals1　= new LinkedList<>();

Hier haben wir eine Liste animals mit der List-Schnittstelle deklariert1, die Liste kann nur Methoden der List-Schnittstelle aufrufen.

Lassen Sie uns noch ein Beispiel nennen.

Queue<String> animals2　= new LinkedList<>();
Deque<String> animals3　= new LinkedList<>();

Hier, animal2kann Methoden der Queue-Schnittstelle aufrufen.

Aber, animal3nur Methoden, die auf die Deque- und Queue-Schnittstellen zugreifen können. Dies liegt daran, dass Deque ein Unterinterface von Queue ist.

Methoden von LinkedList

LinkedList bietet verschiedene Methoden, mit denen wir verschiedene Operationen in der Liste ausführen können.

Element hinzufügen zur LinkedList

1.Element hinzufügen:}Verwenden Sie die Methode add()

Um ein Element (Knoten) am Ende der Liste hinzuzufügen, verwenden wir die Methode add(). Zum Beispiel,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Element hinzufügen zur LinkedList
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Cat, Horse]

2.Element hinzufügen: Verwenden Sie den Index

Wir können auch Elemente zur Liste hinzufügen, indem wir den Index verwenden. Zum Beispiel,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Element hinzufügen mit Index
　　　　　　　　animals.add(0,"Dog");
　　　　　　　　animals.add(1,"Cat");
　　　　　　　　animals.add(2,"Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Cat, Horse]

3.Element hinzufügen: Fügen Sie eine Liste zu einer anderen Liste hinzu

Um alle Elemente der Liste zu einer anderen Liste hinzuzufügen, verwenden wir die Methode addAll(). Zum Beispiel,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> mammals = new LinkedList<>();
　　　　　　　　mammals.add("Dog");
　　　　　　　　mammals.add("Cat");
　　　　　　　　mammals.add("Horse");
　　　　　　　　System.out.println("Mammals: ")　+　mammals);
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Crocodile");
　　　　　　　　//Fügen Sie alle Elemente von mammals zu animals hinzu
　　　　　　　　animals.addAll(mammals);
　　　　　　　　System.out.println("Animals: ")　+　animals);
　　　　}
}

Ausgaberesultat

Mammals: [Dog, Cat, Horse]
Animals: [Crocodile, Dog, Cat, Horse]

4.Element hinzufügen: Verwenden Sie die Methode listIterator()

Wir können auch die Methode listsIterator() verwenden, um Elemente zur Liste hinzuzufügen. Um sie zu verwenden, müssen wir das Paket java.util.ListIterator importieren. Zum Beispiel,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Erstellen Sie ein ListIterator-Objekt
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.add("Dog");
　　　　　　　　listIterate.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Cat]

LinkedList-Elemente aufrufen

1.Elemente aufrufen: Verwenden Sie die Methode get()

Um Elemente der Liste anzuschauen, können wir die Methode get() verwenden. Zum Beispiel,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Elemente aus der Liste abrufen
　　　　　　　　String str = animals.get(1);
　　　　　　　　System.out.print("Index1an der Stelle des Elements: "　+　str);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Pferd, Kat]
Index1an der Stelle des Elements: Horse

2.Elemente aufrufen: Verwenden Sie die Methode iterator()

Um die Elemente eines Linkslists zu durchlaufen, können wir die Methode iterator() verwenden. Wir müssen das Paket java.util.Iterator importieren, um diese Methode zu verwenden. Zum Beispiel,

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//Erstellen Sie ein Objekt des Typs Iterator
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("LinkedList: ");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Ausgaberesultat

LinkedList: Dog, Cat, Horse,

Hier,

• hasNext() - Wenn ein nächstes Element vorhanden ist, wird true zurückgegeben

• next() - Rückgabe des nächsten Elements

3. Elemente zugreifen: Verwenden Sie die Methode listIterator()

Wir können auch die Methode listIterator() verwenden, um die Elemente einer Linked-List zu durchsuchen. Um diese Methode zu verwenden, müssen wir das Paket java.util.ListIterator importieren.

Die Methode listsIterator() ist besser geeignet für Listen. Dies liegt daran, dass das Objekt von listIterator() auch rückwärts iterieren kann. Zum Beispiel

import java.util.LinkedList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//Erstellen Sie ein ListIterator-Objekt
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　System.out.print("LinkedList: ");
　　　　　　　　while(listIterate.hasNext()) {
　　　　　　　　　　　　System.out.print(listIterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//　Nach vorne durchsuchen
　　　　　　　　System.out.print("\nUmgekehrte LinkedList: ");
　　　　　　　　while(listIterate.hasPrevious()) {
　　　　　　　　　　　　System.out.print(listIterate.previous());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Ausgaberesultat

LinkedList: Dog, Horse, Cat,
Umgekehrte LinkedList: Cat, Horse, Dog,

Hier,

• hasNext() - Wenn ein nächstes Element vorhanden ist, wird true zurückgegeben

• next() - Rückgabe des nächsten Elements

• hasPrevious() - Wenn ein vorheriges Element vorhanden ist, wird true zurückgegeben

• previous() - Rückgabe des vorherigen Elements

Suchen von LinkedList-Elementen

1. Suchen von Elementen: Verwenden Sie die Methode contains()

Um zu überprüfen, ob eine Liste bestimmte Elemente enthält, verwenden wir die Methode contains(). Zum Beispiel,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Überprüfen Sie, ob Dog in der Liste enthalten ist
　　　　　　　　if(animals.contains("Dog")) {
　　　　　　　　　　　　System.out.println("Dog befindet sich in der LinkedList.");
　　　　　　　　}
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Pferd, Kat]
Dog befindet sich in der LinkedList.

2. Suchen von Elementen: Verwenden Sie die Methode indexOf()

• indexOf() - Rückgabe des Index des ersten Auftretens des Elements

• lastIndexOf() - Rückgabe des Index des letzten Auftretens des Elements

Zum Beispiel,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//　Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Der erste Auftreten von Dog
　　　　　　　　int index1　= animals.indexOf("Dog");
　　　　　　　　System.out.println("Der erste Auftretensindex von Dog: ","　+　Index1);
　　　　　　　　//Das letzte Auftreten von Dog
　　　　　　　　int index2　= animals.lastIndexOf("Dog");
　　　　　　　　System.out.println("Letzte Indexposition von Dog:")　+　Index2);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Horse, Cat, Dog]
Erste Indexposition von Dog: 0
Letzte Indexposition von Dog:　3

Hinweis:Falls das angegebene Element nicht gefunden wird, geben indexOf() und lastIndexOf() beide zurück-1.

Ändern von LinkedList-Elementen

1.Ändern von Elementen: Verwenden Sie die Methode set()

Um Elemente in einer verknüpften Liste zu ändern, können wir die Methode set() verwenden. Zum Beispiel,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Ändern von Index3der Elemente
　　　　　　　　animals.set(3, "Zebra");
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Horse, Cat, Dog]
Neue LinkedList: [Dog, Horse, Cat, Zebra]

2.Ändern von Elementen: Verwenden Sie die Methode listIterator()

Wir können auch die Methode listIterator() verwenden, um Elemente in einer verknüpften Liste zu ändern. Zum Beispiel,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//　Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Erstellen Sie ein ListIterator-Objekt
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//Ändern des Elements, das von next() zurückgegeben wird
　　　　　　　　listIterate.set("Cow");
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Cat, Horse]
Neue LinkedList: [Cow, Cat, Horse]

Entfernen von LinkedList-Elementen

1.Entfernen von Elementen: Verwenden Sie die Methode remove()

Um Elemente aus einer verknüpften Liste zu entfernen, können wir die Methode remove() verwenden. Zum Beispiel,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Zebra");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Entfernen von Index1der Elemente
　　　　　　　　String str = animals.remove(1);
　　　　　　　　System.out.println("Entfernen von Elementen: ")　+　str);
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Horse, Cat, Zebra]
Entfernen von Elementen: Horse
Neue LinkedList: [Dog, Cat, Zebra]

2.Entfernen von Elementen: Verwenden Sie die Methode listIterator()

Wir können auch die Methode listsIterator() verwenden, um Elemente aus einer verknüpften Liste zu entfernen. Zum Beispiel,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Erstellen Sie ein ListIterator-Objekt
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//Löschen Sie das Element, das von next() zurückgegeben wird
　　　　　　　　listIterate.remove();
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Cat, Horse]
Neue LinkedList: [Cat, Horse]

3. Elemente löschen: Verwenden Sie die Methode clear()

Um alle Elemente aus der verknüpften Liste zu löschen, verwenden wir die Methode clear(). Zum Beispiel:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Löschen Sie alle Elemente
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Cat, Horse]
Neue LinkedList: []

Hinweis:Wir können auch die Methode removeAll() verwenden, um alle Elemente zu löschen. Allerdings ist die Methode clear() effizienter als removeAll().

4. Elemente löschen: Verwenden Sie die Methode removeIf()

Wenn ein Element bestimmte Bedingungen erfüllt, können wir es auch aus der Liste löschen. Dafür verwenden wir die Methode removeIf(). Zum Beispiel:

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<Integer> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add(2);
　　　　　　　　animals.add(3);
　　　　　　　　animals.add(4);
　　　　　　　　animals.add(5);
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//　Löschen Sie alle kleineren als4der Elemente
　　　　　　　　animals.removeIf((Integer i)->i <　4);
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　　　　/**　Hier verwenden wir Lambda-Ausdrücke
　　　　　　　*　　Jetzt erinnern Sie sich
　　　　　　　*　　Der Parameter von removeIf() ist eine Bedingung
　　　　　　　*/
　　　　}
}

Ausgaberesultat

LinkedList: [2,　3,　4,　5]
Neue LinkedList: [4,　5]

Hinweis: (Integer i)->i<4 Ist ein Lambda-Ausdruck. Um Lambda-Ausdrücke zu verstehen, besuchen Sie bitteJava Lambda-Ausdrücke

LinkedList als Deque und Queue

Da die LinkedList-Klasse auch die Interfaces Queue und Deque implementiert, kann sie diese Methoden ebenfalls implementieren. Hier sind einige häufig verwendete Methoden:

addFirst() und addLast() Methoden

• addFirst() - Fügen Sie das angegebene Element am Anfang der verknüpften Liste hinzu

• addLast() - Fügen Sie das angegebene Element am Ende der verknüpften Liste hinzu

Zum Beispiel,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//Elemente am Anfang der LinkedList hinzufügen
　　　　　　　　animals.addFirst("Cow");
　　　　　　　　animals.addFirst("Dog");
　　　　　　　　animals.addFirst("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Ein Element am Ende der LinkedList hinzufügen
　　　　　　　　animals.addLast("Zebra");
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Kat, Dog, Kuh]
neue LinkedList: [Kat, Dog, Kuh, Zebra]

getFirst() und getLast() Methoden

• getFirst() - erstes Element zurückgeben

• getLast() - letztes Element zurückgeben

Zum Beispiel,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//　Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//erstes Element aus der Liste holen
　　　　　　　　String str1　= animals.getFirst();
　　　　　　　　System.out.println("erstes Element: ");　+　str1);
　　　　　　　　//letztes Element aus der Liste holen
　　　　　　　　String str2　= animals.getLast();
　　　　　　　　System.out.println("letztes Element: ");　+　str2);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Pferd, Kat]
erstes Element: Dog
letztes Element: Kat

removeFirst() und removeLast() Methoden

• removeFirst() - erstes Element löschen

• removeLast() - letztes Element löschen

Zum Beispiel,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//　Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Erstes Element aus der LinkedList löschen
　　　　　　　　String str1　= animals.removeFirst();
　　　　　　　　System.out.println("gelöschtes Element: ");　+　str1);
　　　　　　　　//Element am Ende der LinkedList löschen
　　　　　　　　String str2　= animals.removeLast();
　　　　　　　　System.out.println("gelöschtes Element: ");　+　str2);
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Pferd, Kat]
gelöschtes Element: Dog
gelöschtes Element: Kat
neue LinkedList: [Pferd]

peek() Methode

Die peek() Methode gibt das erste Element der Liste (Kopf) zurück. Zum Beispiel,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Ansicht des ersten Elements der LinkedList
　　　　　　　　String str = animals.peek();
　　　　　　　　System.out.println("Elementansicht: ");　+　str);
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Pferd, Kat]
Elementansicht: Dog
Neue LinkedList: [Dog, Horse, Cat]

poll() Methode

Die poll() Methode gibt das erste Element zurück und löscht es aus der Liste. Zum Beispiel,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Rückgabe und Löschung des ersten Elements
　　　　　　　　String str = animals.poll();
　　　　　　　　System.out.println("gelöschtes Element: ");　+　str);
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Pferd, Kat]
gelöschtes Element: Dog
neue LinkedList: [Pferd, Kat]

offer() Methode

Die Methode offer() fügt das angegebene Element am Ende der verknüpften Liste hinzu. Zum Beispiel,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//Ein Element zur Liste hinzufügen
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Ein Element am Ende der LinkedList hinzufügen
　　　　　　　　animals.offer("Cat");
　　　　　　　　System.out.println("Neue LinkedList: " );　+　animals);
　　　　}
}

Ausgaberesultat

LinkedList: [Dog, Horse]
Neue LinkedList: [Dog, Horse, Cat]

Durchlauf der LinkedList-Iteration

1.Verwendung von forEach-Schleife durchlaufen

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Eine Liste erstellen
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Verwendung von forEach-Schleife
　　　　　　　　System.out.println("Listenelemente aufrufen:");
　　　　　　　　for(String animal: animals) {
　　　　　　　　　　　　System.out.print(animal);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Ausgaberesultat

LinkedList: [Kuh, Katze, Hund]
Listenelemente aufrufen:
Kuh, Katze, Hund,

2.Verwendung von for-Schleife

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Eine Liste erstellen
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Verwendung von for-Schleife
　　　　　　　　System.out.println("Listenelemente aufrufen:");
　　　　　　　　for(int i = 0; i < animals.size(); i++) {
　　　　　　　　　　　　System.out.print(animals.get(i));
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Ausgaberesultat

LinkedList: [Kuh, Katze, Hund]
Listenelemente aufrufen:
Kuh, Katze, Hund,

In beiden Beispielen verwenden wir einen Durchlauf, um auf die verschiedenen Elemente der Liste zuzugreifen.

3.Verwendung der iterator() Methode

Wir können die iterator() Methode verwenden, um auf die Elemente der Liste zuzugreifen. Um diese Methode zu verwenden, müssen wir das Paket java.util.Iterator importieren.

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Eine Liste erstellen
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: " );　+　animals);
　　　　　　　　//Verwendung der iterator() Methode
　　　　　　　　System.out.println("LinkedList verwendet iterator() Methode:");
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Ausgaberesultat

LinkedList: [Kuh, Katze, Hund]
LinkedList verwendet die Methode iterator():
Kuh, Katze, Hund,

LinkedList und ArrayList

LinkedList und ArrayList implementieren beide das List Interface des Collections-Frameworks. Es gibt jedoch einige Unterschiede zwischen ihnen.