Java LinkedList

In diesem Tutorial lernen wir die Java LinkedList anhand von Beispielen im Detail kennen.

Der LinkedList Klasse des Java Collections Framework stellt die Funktionalität der Linked-List-Datenstruktur (Double LinkedList) bereit.

Jedes Element in einer verknüpften Liste wird als Knoten bezeichnet . Es besteht aus 3 Feldern:

Zurück - speichert eine Adresse des vorherigen Elements in der Liste. Es ist null für das erste Element
Weiter - speichert eine Adresse des nächsten Elements in der Liste. Es ist null für das letzte Element
Daten - speichert die aktuellen Daten

Erstellen einer Java LinkedList

So können wir verknüpfte Listen in Java erstellen:

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

Hier Typ gibt den Typ einer verknüpften Liste an. Zum Beispiel

// create Integer type linked list
LinkedList<Integer> linkedList = new LinkedList<>();

// create String type linked list
LinkedList<String> linkedList = new LinkedList<>();

Beispiel:LinkedList in Java erstellen

import java.util.LinkedList;

class Main {
  public static void main(String[] args){

    // create linkedlist
    LinkedList<String> animals = new LinkedList<>();

    // Add elements to LinkedList
    animals.add("Dog");
    animals.add("Cat");
    animals.add("Cow");
    System.out.println("LinkedList: " + animals);
  }
}

Ausgabe

LinkedList: [Dog, Cat, Cow]

Im obigen Beispiel haben wir einen LinkedList erstellt namens Tiere .

Hier haben wir den add() verwendet Methode zum Hinzufügen von Elementen zur LinkedList. Wir werden mehr über die add() erfahren -Methode später in diesem Tutorial.

Arbeiten einer Java LinkedList

Elemente in verknüpften Listen werden nicht der Reihe nach gespeichert. Stattdessen sind sie verstreut und durch Links verbunden (Zurück und Weiter ).

Hier haben wir 3 Elemente in einer verknüpften Liste.

Hund - es ist das erste Element, das null enthält als vorherige Adresse und die Adresse von Cat als nächste Adresse
Katze - es ist das zweite Element, das eine Adresse von Dog enthält wie die vorherige Adresse und die Adresse von Cow als nächste Adresse
Kuh - es ist das letzte Element, das die Adresse von Cat enthält wie die vorherige Adresse und null als nächstes Element

Um mehr zu erfahren, besuchen Sie die LinkedList-Datenstruktur.

Methoden von Java LinkedList

LinkedList bietet verschiedene Methoden, mit denen wir verschiedene Operationen in verknüpften Listen ausführen können. In diesem Tutorial werden wir uns vier häufig verwendete LinkedList-Operatoren ansehen:

Elemente hinzufügen
Access-Elemente
Elemente ändern
Elemente entfernen

1. Elemente zu einer LinkedList hinzufügen

Wir können den add() verwenden Methode, um ein Element (Knoten) am Ende der LinkedList hinzuzufügen. Zum Beispiel

import java.util.LinkedList;

class Main {
  public static void main(String[] args){
    // create linkedlist
    LinkedList<String> animals = new LinkedList<>();

    // add() method without the index parameter
    animals.add("Dog");
    animals.add("Cat");
    animals.add("Cow");
    System.out.println("LinkedList: " + animals);

    // add() method with the index parameter
    animals.add(1, "Horse");
    System.out.println("Updated LinkedList: " + animals);
  }
}

Ausgabe

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

Im obigen Beispiel haben wir eine LinkedList mit dem Namen animals erstellt . Hier haben wir den add() verwendet Methode zum Hinzufügen von Elementen zu Tieren .

Beachten Sie die Anweisung,

animals.add(1, "Horse");

Hier haben wir die Indexnummer verwendet Parameter. Es ist ein optionaler Parameter, der die Position angibt, an der das neue Element hinzugefügt wird.

Um mehr über das Hinzufügen von Elementen zu LinkedList zu erfahren, besuchen Sie das Java-Programm zum Hinzufügen von Elementen zu LinkedList.

2. Greifen Sie auf LinkedList-Elemente zu

Die get() -Methode der LinkedList-Klasse wird verwendet, um auf ein Element aus der LinkedList zuzugreifen. Zum Beispiel

import java.util.LinkedList;

class Main {
  public static void main(String[] args) {
    LinkedList<String> languages = new LinkedList<>();

    // add elements in the linked list
    languages.add("Python");
    languages.add("Java");
    languages.add("JavaScript");
    System.out.println("LinkedList: " + languages);

    // get the element from the linked list
    String str = languages.get(1);
    System.out.print("Element at index 1: " + str);
  }
}

Ausgabe

LinkedList: [Python, Java, JavaScript]
Element at index 1: Java

Im obigen Beispiel haben wir den get() verwendet Methode mit dem Parameter 1 . Hier gibt die Methode das Element am Index 1 zurück .

Wir können auch mit dem iterator() auf Elemente der LinkedList zugreifen und die listIterator() Methode. Um mehr zu erfahren, besuchen Sie das Java-Programm, um auf Elemente von LinkedList zuzugreifen.

3. Elemente einer LinkedList ändern

Die set() Methode von LinkedList Klasse wird verwendet, um Elemente der LinkedList zu ändern. Zum Beispiel

import java.util.LinkedList;

class Main {
  public static void main(String[] args) {
    LinkedList<String> languages = new LinkedList<>();

    // add elements in the linked list
    languages.add("Java");
    languages.add("Python");
    languages.add("JavaScript");
    languages.add("Java");
    System.out.println("LinkedList: " + languages);

    // change elements at index 3
    languages.set(3, "Kotlin");
    System.out.println("Updated LinkedList: " + languages);
  }
}

Ausgabe

LinkedList: [Java, Python, JavaScript, Java]
Updated LinkedList: [Java, Python, JavaScript, Kotlin]

Im obigen Beispiel haben wir eine LinkedList mit dem Namen Sprachen erstellt. Beachten Sie die Zeile,

languages.set(3, "Kotlin");

Hier der set() -Methode ändert das Element am Index 3 zu Kotlin .

4. Element aus einer LinkedList entfernen

Die remove() Methode des LinkedList Klasse wird verwendet, um ein Element aus der LinkedList zu entfernen. Zum Beispiel

import java.util.LinkedList;

class Main {
  public static void main(String[] args) {
    LinkedList<String> languages = new LinkedList<>();

    // add elements in LinkedList
    languages.add("Java");
    languages.add("Python");
    languages.add("JavaScript");
    languages.add("Kotlin");
    System.out.println("LinkedList: " + languages);

    // remove elements from index 1
    String str = languages.remove(1);
    System.out.println("Removed Element: " + str);

    System.out.println("Updated LinkedList: " + languages);
  }
}

Ausgabe

LinkedList: [Java, Python, JavaScript, Kotlin]
Removed Element: Python
New LinkedList: [Java, JavaScript, Kotlin]

Hier die remove() Methode nimmt die Indexnummer als Parameter. Und entfernt das durch die Indexnummer angegebene Element.

Um mehr über das Entfernen von Elementen aus der LinkedList zu erfahren, besuchen Sie das Java-Programm zum Entfernen von Elementen aus LinkedList..

Andere Methoden

Methoden	Beschreibung
`contains()`	überprüft, ob die LinkedList das Element enthält
`indexOf()`	gibt den Index des ersten Vorkommens des Elements zurück
`lastIndexOf()`	gibt den Index des letzten Vorkommens des Elements zurück
`clear()`	entfernt alle Elemente der LinkedList
`iterator()`	gibt einen Iterator zurück, um LinkedList zu durchlaufen

LinkedList als Deque und Queue

Seit dem LinkedList Klasse auch die Queue- und die Deque-Schnittstelle implementiert, kann sie auch Methoden dieser Schnittstellen implementieren. Hier sind einige der am häufigsten verwendeten Methoden:

Methoden	Beschreibungen
`addFirst()`	fügt das angegebene Element am Anfang der verknüpften Liste hinzu
`addLast()`	fügt das angegebene Element am Ende der verknüpften Liste hinzu
`getFirst()`	gibt das erste Element zurück
`getLast()`	gibt das letzte Element zurück
`removeFirst()`	entfernt das erste Element
`removeLast()`	entfernt das letzte Element
`peek()`	gibt das erste Element (Kopf) der verknüpften Liste zurück
`poll()`	gibt das erste Element aus der verknüpften Liste zurück und entfernt es
`offer()`	fügt das angegebene Element am Ende der verknüpften Liste hinzu

Beispiel:Java LinkedList als Warteschlange

import java.util.LinkedList;
import java.util.Queue;

class Main {
  public static void main(String[] args) {
    Queue<String> languages = new LinkedList<>();

    // add elements
    languages.add("Python");
    languages.add("Java");
    languages.add("C");
    System.out.println("LinkedList: " + languages);

    // access the first element
    String str1 = languages.peek();
    System.out.println("Accessed Element: " + str1);

    // access and remove the first element
    String str2 = languages.poll();
    System.out.println("Removed Element: " + str2);
    System.out.println("LinkedList after poll(): " + languages);

    // add element at the end
    languages.offer("Swift");
    System.out.println("LinkedList after offer(): " + languages);
  }
}

Ausgabe

LinkedList: [Python, Java, C]
Accessed Element: Python
Removed Element: Python
LinkedList after poll(): [Java, C]
LinkedList after offer(): [Java, C, Swift]

Beispiel:LinkedList als Deque

import java.util.LinkedList;
import java.util.Deque;

class Main {
  public static void main(String[] args){
    Deque<String> animals = new LinkedList<>();

    // add element at the beginning
    animals.add("Cow");
    System.out.println("LinkedList: " + animals);

    animals.addFirst("Dog");
    System.out.println("LinkedList after addFirst(): " + animals);

    // add elements at the end
    animals.addLast("Zebra");
    System.out.println("LinkedList after addLast(): " + animals);

    // remove the first element
    animals.removeFirst();
    System.out.println("LinkedList after removeFirst(): " + animals);

    // remove the last element
    animals.removeLast();
    System.out.println("LinkedList after removeLast(): " + animals);
  }
}

Ausgabe

LinkedList: [Cow]
LinkedList after addFirst(): [Dog, Cow]
LinkedList after addLast(): [Dog, Cow, Zebra]
LinkedList after removeFirst(): [Cow, Zebra]
LinkedList after removeLast(): [Cow]

Durch LinkedList iterieren

Wir können die Java-for-each-Schleife verwenden, um LinkedList zu durchlaufen. Zum Beispiel

import java.util.LinkedList;

class Main {
    public static void main(String[] args) {
        // Creating a linked list
        LinkedList<String> animals = new LinkedList<>();
        animals.add("Cow");
        animals.add("Cat");
        animals.add("Dog");
        System.out.println("LinkedList: " + animals);

        // Using forEach loop
        System.out.println("Accessing linked list elements:");
        for(String animal: animals) {
            System.out.print(animal);
            System.out.print(", ");
        }
    }
}

Ausgabe

LinkedList: [Cow, Cat, Dog]
Accessing linked list elements:
Cow, Cat, Dog,

LinkedList vs. ArrayList

Sowohl die Java ArrayList als auch LinkedList implementiert den List Schnittstelle des Collections Rahmen. Es gibt jedoch einige Unterschiede zwischen ihnen.

LinkedList	ArrayList
Implementiert `List` , `Queue` , und `Deque` Schnittstellen.	Implementiert `List` Schnittstelle.
Speichert 3 Werte (vorherige Adresse , Daten und nächste Adresse ) in einer einzigen Position.	Speichert einen einzelnen Wert an einer einzelnen Position.
Stellt die Implementierung der doppelt verknüpften Liste bereit.	Stellt eine veränderbare Array-Implementierung bereit.
Immer wenn ein Element hinzugefügt wird, `prev` und `next` Adresse geändert.	Wann immer ein Element hinzugefügt wird, werden alle Elemente nach dieser Position verschoben.
Um auf ein Element zuzugreifen, müssen wir vom Anfang bis zum Element iterieren.	Kann mithilfe von Indizes wahlfrei auf Elemente zugreifen.

Hinweis :Wir können auch eine LinkedList mit Schnittstellen in Java erstellen. Zum Beispiel

// create linkedlist using List
List<String> animals1 = new LinkedList<>();

// creating linkedlist using Queue
Queue<String> animals2 = new LinkedList<>();

// creating linkedlist using Deque
Deque<String> animals3 = new LinkedList<>();

Wenn die LinkedList hier mit einer Schnittstelle erstellt wird, können wir keine Methoden verwenden, die von anderen Schnittstellen bereitgestellt werden. Das heißt, Tiere1 kann keine für Queue spezifischen Methoden verwenden und Deque Schnittstellen.

Java-Deque-Schnittstelle Java ArrayDeque

Java