Java ArrayDeque

Java-ArrayDeque

In diesem Tutorial lernen wir die Klasse ArrayDeque und ihre Methoden anhand von Beispielen kennen. Außerdem werden wir lernen, Array-Deques zu verwenden, um einen Stack zu implementieren.

In Java können wir den ArrayDeque verwenden Klasse zum Implementieren von Queue- und Deque-Datenstrukturen mithilfe von Arrays.

Von ArrayDeque implementierte Schnittstellen

Die ArrayDeque Klasse implementiert diese beiden Schnittstellen:

Java-Warteschlangenschnittstelle
Java-Deque-Schnittstelle

ArrayDeque erstellen

Um eine Array-Deque zu erstellen, müssen wir den java.util.ArrayDeque importieren Paket.

So können wir eine Array-Deque in Java erstellen:

ArrayDeque<Type> animal = new ArrayDeque<>();

Hier Typ gibt den Typ der Array-Doppelschlange an. Zum Beispiel

// Creating String type ArrayDeque
ArrayDeque<String> animals = new ArrayDeque<>();

// Creating Integer type ArrayDeque
ArrayDeque<Integer> age = new ArrayDeque<>();

Methoden von ArrayDeque

Die ArrayDeque -Klasse stellt Implementierungen für alle Methoden bereit, die in Queue vorhanden sind und Deque Schnittstelle.

Elemente zum Dequen einfügen

1. Fügen Sie Elemente mit add(), addFirst() und addLast() hinzu

add() - fügt das angegebene Element am Ende der Array-Deque ein
addFirst() - fügt das angegebene Element am Anfang der Array-Deque ein
addLast() - fügt die angegebene am Ende der Array-Deque ein (entspricht add() )

Hinweis: Wenn das Array deque voll ist, werden alle diese Methoden add() , addFirst() und addLast() wirft IllegalStateException .

Zum Beispiel

import java.util.ArrayDeque;

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

        // Using add()
        animals.add("Dog");

        // Using addFirst()
        animals.addFirst("Cat");

        // Using addLast()
        animals.addLast("Horse");
        System.out.println("ArrayDeque: " + animals);
    }
}

Ausgabe

ArrayDeque: [Cat, Dog, Horse]

2. Fügen Sie Elemente mit offer(), offerFirst() und offerLast() ein

offer() - fügt das angegebene Element am Ende der Array-Deque ein
offerFirst() - fügt das angegebene Element am Anfang der Array-Deque ein
offerLast() - fügt das angegebene Element am Ende der Array-Deque ein

Hinweis: offer() , offerFirst() und offerLast() gibt true zurück wenn das Element erfolgreich eingefügt wurde; Wenn die Array-Deque voll ist, geben diese Methoden false zurück .

Zum Beispiel

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        // Using offer()
        animals.offer("Dog");

        // Using offerFirst()
        animals.offerFirst("Cat");

        // Using offerLast()
        animals.offerLast("Horse");
        System.out.println("ArrayDeque: " + animals);
    }
}

Ausgabe

ArrayDeque: [Cat, Dog, Horse]

Hinweis: Wenn das Array deque voll ist

der add() -Methode löst eine Ausnahme aus
der offer() Methode gibt false zurück

Zugriff auf ArrayDeque-Elemente

1. Greifen Sie mit getFirst() und getLast() auf Elemente zu

getFirst() - gibt das erste Element des Array deque zurück
getLast() - gibt das letzte Element des Array deque

Hinweis: Wenn die Array-Deque leer ist, getFirst() und getLast() wirft NoSuchElementException .

Zum Beispiel

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayDeque: " + animals);

        // Get the first element
        String firstElement = animals.getFirst();
        System.out.println("First Element: " + firstElement);

        // Get the last element
        String lastElement = animals.getLast();
        System.out.println("Last Element: " + lastElement);
    }
}

Ausgabe

ArrayDeque: [Dog, Cat, Horse]
First Element: Dog
Last Element: Horse

2. Greifen Sie mit den Methoden peek(), peekFirst() und peekLast() auf Elemente zu

peek() - gibt das erste Element des Array deque zurück
peekFirst() - gibt das erste Element des Array deque zurück (entspricht peek() )
peekLast() - gibt das letzte Element des Array deque

Zum Beispiel

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayDeque: " + animals);

        // Using peek()
        String element = animals.peek();
        System.out.println("Head Element: " + element);

        // Using peekFirst()
        String firstElement = animals.peekFirst();
        System.out.println("First Element: " + firstElement);

        // Using peekLast
        String lastElement = animals.peekLast();
        System.out.println("Last Element: " + lastElement);
    }
}

Ausgabe

ArrayDeque: [Dog, Cat, Horse]
Head Element: Dog
First Element: Dog
Last Element: Horse

Hinweis: Wenn die Array-Deque leer ist, peek() , peekFirst() und getLast() wirft NoSuchElementException .

ArrayDeque-Elemente entfernen

1. Entfernen Sie Elemente mit der Methode remove(), removeFirst(), removeLast()

remove() - gibt ein Element aus dem ersten Element des Array deque zurück und entfernt es
remove(element) - gibt das angegebene Element aus dem Kopf der Array-Deque zurück und entfernt es
removeFirst() - gibt das erste Element aus der Array-Deque zurück und entfernt es (entspricht remove() )
removeLast() - gibt das letzte Element aus dem Array deque zurück und entfernt es

Hinweis: Wenn die Array-Deque leer ist, remove() , removeFirst() und removeLast() Methode löst eine Ausnahme aus. Auch remove(element) löst eine Ausnahme aus, wenn das Element nicht gefunden wird.

Zum Beispiel

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Cow");
        animals.add("Horse");
        System.out.println("ArrayDeque: " + animals);

        // Using remove()
        String element = animals.remove();
        System.out.println("Removed Element: " + element);

        System.out.println("New ArrayDeque: " + animals);

        // Using removeFirst()
        String firstElement = animals.removeFirst();
        System.out.println("Removed First Element: " + firstElement);

        // Using removeLast()
        String lastElement = animals.removeLast();
        System.out.println("Removed Last Element: " + lastElement);
    }
}

Ausgabe

ArrayDeque: [Dog, Cat, Cow, Horse]
Removed Element: Dog
New ArrayDeque: [Cat, Cow, Horse]
Removed First Element: Cat
Removed Last Element: Horse

2. Entfernen Sie Elemente mit den Methoden poll(), pollFirst() und pollLast()

poll() - gibt das erste Element des Array deque zurück und entfernt es
pollFirst() - gibt das erste Element der Array-Doppelschlange zurück und entfernt es (entspricht poll() )
pollLast() - gibt das letzte Element des Array deque zurück und entfernt es

Hinweis: Wenn die Array-Deque leer ist, poll() , pollFirst() und pollLast() gibt null zurück wenn das Element nicht gefunden wird.

Zum Beispiel

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Cow");
        animals.add("Horse");
        System.out.println("ArrayDeque: " + animals);

        // Using poll()
        String element = animals.poll();
        System.out.println("Removed Element: " + element);
        System.out.println("New ArrayDeque: " + animals);

        // Using pollFirst()
        String firstElement = animals.pollFirst();
        System.out.println("Removed First Element: " + firstElement);

        // Using pollLast()
        String lastElement = animals.pollLast();
        System.out.println("Removed Last Element: " + lastElement);
    }
}

Ausgabe

ArrayDeque: [Dog, Cat, Cow, Horse]
Removed Element: Dog
New ArrayDeque: [Cat, Cow, Horse]
Removed First Element: Cat
Removed Last Element: Horse

3. Element entfernen:mit der Methode clear()

Um alle Elemente aus der Array-Deque zu entfernen, verwenden wir den clear() Methode. Zum Beispiel

import java.util.ArrayDeque;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayDeque: " + animals);

        // Using clear()
        animals.clear();

        System.out.println("New ArrayDeque: " + animals);
    }
}

Ausgabe

ArrayDeque: [Dog, Cat, Horse]
New ArrayDeque: []

Iteration der ArrayDeque

iterator() - gibt einen Iterator zurück, der verwendet werden kann, um über das Array deque zu iterieren
descendingIterator() - gibt einen Iterator zurück, der verwendet werden kann, um das Array deque in umgekehrter Reihenfolge zu durchlaufen

Um diese Methoden verwenden zu können, müssen wir den java.util.Iterator importieren Paket. Zum Beispiel

import java.util.ArrayDeque;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        ArrayDeque<String> animals= new ArrayDeque<>();
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");

        System.out.print("ArrayDeque: ");

        // Using iterator()
        Iterator<String> iterate = animals.iterator();
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }

        System.out.print("\nArrayDeque in reverse order: ");
        // Using descendingIterator()
        Iterator<String> desIterate = animals.descendingIterator();
        while(desIterate.hasNext()) {
            System.out.print(desIterate.next());
            System.out.print(", ");
        }
    }
}

Ausgabe

ArrayDeque: [Dog, Cat, Horse]
ArrayDeque in reverse order: [Horse, Cat, Dog]

Andere Methoden

Methoden	Beschreibungen
`element()`	Gibt ein Element aus dem Kopf der Array-Deque zurück.
`contains(element)`	Durchsucht das Array deque nach dem angegebenen Element. Wenn das Element gefunden wird, gibt es `true` zurück , wenn nicht, wird `false` zurückgegeben .
`size()`	Gibt die Länge der Array-Deque zurück.
`toArray()`	Konvertiert Array deque in Array und gibt es zurück.
`clone()`	Erzeugt eine Kopie der Array-Deque und gibt sie zurück.

ArrayDeque als Stack

Zur Implementierung eines LIFO (Last-In-First-Out) Stacks in Java wird empfohlen, eine Deque über der Stack-Klasse zu verwenden. Der ArrayDeque Klasse ist wahrscheinlich schneller als Stack Klasse.

ArrayDeque stellt die folgenden Methoden bereit, die zum Implementieren eines Stacks verwendet werden können.

push() - fügt ein Element oben auf dem Stapel hinzu
peek() - gibt ein Element von der Spitze des Stacks zurück
pop() - gibt ein Element von der Spitze des Stapels zurück und entfernt es

Zum Beispiel

import java.util.ArrayDeque;

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

        // Add elements to stack
        stack.push("Dog");
        stack.push("Cat");
        stack.push("Horse");
        System.out.println("Stack: " + stack);

        // Access element from top of stack
        String element = stack.peek();
        System.out.println("Accessed Element: " + element);

        // Remove elements from top of stack
        String remElement = stack.pop();
        System.out.println("Removed element: " + remElement);
    }
}

Ausgabe

Stack: [Horse, Cat, Dog]
Accessed Element: Horse
Removed Element: Horse

ArrayDeque Vs. LinkedList-Klasse

Beide ArrayDeque und Java LinkedList implementiert den Deque Schnittstelle. Es gibt jedoch einige Unterschiede zwischen ihnen.

LinkedList unterstützt null Elemente, wohingegen ArrayDeque nicht.
Jeder Knoten in einer verknüpften Liste enthält Links zu anderen Knoten. Deshalb LinkedList erfordert mehr Speicherplatz als ArrayDeque .
Wenn Sie die Queue- oder die Deque-Datenstruktur implementieren, ein ArrayDeque ist wahrscheinlich schneller als ein LinkedList .

Java LinkedList Java BlockingQueue

Java