ArrayDeque Java

In questo tutorial, esploreremo la classe ArrayDeque e i suoi metodi con esempi. Inoltre, impareremo come utilizzare ArrayDeque per implementare lo stack.

In Java, possiamo utilizzare la classe ArrayDeque per implementare la struttura dati di coda e deque utilizzando array.

Interfacce implementate da ArrayDeque

Esempi di implementazione di queste interfacce in ArrayDeque:

• Interfaccia Queue Java

• Interfaccia Java Deque

Creare ArrayDeque

Per creare una coda a due estremità ArrayDeque, dobbiamo importare il pacchetto java.util.ArrayDeque.

Ecco come possiamo creare una coda a due estremità ArrayDeque in Java:

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

In questo caso, Type rappresenta il tipo della coda a due estremità ArrayDeque. Ad esempio,

//Creare ArrayDeque di tipo stringa
ArrayDeque<String> animals = new ArrayDeque<>();
//Creare ArrayDeque di tipo intero
ArrayDeque<Integer> age = new ArrayDeque<>();

Metodi ArrayDeque

La classe ArrayDeque fornisce tutti i metodi esistenti negli interfacce Queue e Deque.

Inserire elementi nella coda a due estremità

1. Usare add(), addFirst() e addLast() per aggiungere elementi

• add() - Inserisce l'elemento specificato alla fine dell'ArrayDeque coda a due estremità

• addFirst() - Inserisce l'elemento specificato all'inizio dell'ArrayDeque coda a due estremità

• addLast() - Inserisce il contenuto specificato alla fine dell'ArrayDeque coda a due estremità (equivalente a add())

Attenzione:Se l'ArrayDeque coda a due estremità è piena, tutti questi metodi add(), addFirst() e addLast() scatenano IllegalStateException.

For example,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　//usare add　()
　　　　　　　　animals.add("Dog");
　　　　　　　　//usare addFirst　()
　　　　　　　　animals.addFirst("Cat");
　　　　　　　　//usare addLast()
　　　　　　　　animals.addLast("Horse");
　　　　　　　　System.out.println("ArrayDeque: \t" + animals);
　　　　}
}

Risultato di output

ArrayDeque: [Cat, Dog, Horse]

2. Usare offer(), offerFirst() e offerLast() per inserire elementi

• offer() - Inserisce l'elemento specificato alla fine dell'ArrayDeque coda a due estremità

• offerFirst() - Inserisce l'elemento specificato all'inizio dell'ArrayDeque coda a due estremità

• offerLast() - Inserisce l'elemento specificato alla fine dell'ArrayDeque coda a due estremità

Attenzione: offer(), offerFirst() e offerLast() restituiscono true se l'elemento è stato inserito con successo; altrimenti, restituiscono. Se l'ArrayDeque coda a due estremità è piena, questi metodi restituiscono false.

For example,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　//usare offer()
　　　　　　　　animals.offer("Dog");
　　　　　　　　//Utilizzo di offerFirst()
　　　　　　　　animals.offerFirst("Cat");
　　　　　　　　//Utilizzo di offerLast()
　　　　　　　　animals.offerLast("Horse");
　　　　　　　　System.out.println("ArrayDeque: \t" + animals);
　　　　}
}

Risultato di output

ArrayDeque: [Cat, Dog, Horse]

Accesso agli elementi dell'ArrayDeque

1. Utilizzo di getFirst() e getLast() per accedere agli elementi

• getFirst() - Restituisce il primo elemento dell'ArrayDeque double-ended queue

• getLast() - Restituisce l'ultimo elemento dell'ArrayDeque double-ended queue

Nota:Se l'ArrayDeque double-ended queue è vuota, getFirst() e getLast() lanciano NoSuchElementException.

For example,

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: \t" + animals);
　　　　　　　　//Ottenimento del primo elemento
　　　　　　　　String firstElement = animals.getFirst();
　　　　　　　　System.out.println("Primo elemento: " + firstElement);
　　　　　　　　//Ottenimento dell'ultimo elemento
　　　　　　　　String lastElement = animals.getLast();
　　　　　　　　System.out.println("Ultimo elemento: " + lastElement);
　　　　}
}

Risultato di output

ArrayDeque: [Dog, Cat, Horse]
Primo elemento: Dog
Ultimo elemento: Horse

2. Utilizzo dei metodi peek(), peekFirst() e peekLast() per accedere agli elementi

• peek() - Restituisce il primo elemento dell'ArrayDeque double-ended queue

• peekFirst() - Restituisce il primo elemento dell'ArrayDeque double-ended queue (equivalente a peek())

• peekLast() - Restituisce l'ultimo elemento dell'ArrayDeque double-ended queue

For example,

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: \t" + animals);
　　　　　　　　//Utilizzo di peek()
　　　　　　　　String element = animals.peek();
　　　　　　　　System.out.println("Elemento in testa: " + element);
　　　　　　　　//Utilizzo di peekFirst()
　　　　　　　　String firstElement = animals.peekFirst();
　　　　　　　　System.out.println("Primo elemento: " + firstElement);
　　　　　　　　//Utilizzo di peekLast
　　　　　　　　String lastElement = animals.peekLast();
　　　　　　　　System.out.println("Ultimo elemento: " + lastElement);
　　　　}
}

Risultato di output

ArrayDeque: [Dog, Cat, Horse]
Elemento in testa: Dog
Primo elemento: Dog
Ultimo elemento: Horse

Attenzione:Se l'ArrayDeque double-ended queue è vuota, peek(), peekFirst() e getLast() lanciano NoSuchElementException.

Eliminare gli elementi ArrayDeque

1. Utilizzare i metodi remove(), removeFirst() e removeLast() per eliminare gli elementi

• remove() - Restituisce ed elimina un elemento dalla testa dell'ArrayDeque a doppio estremo

• remove(element) - Restituisce ed elimina l'elemento specificato dalla testa dell'ArrayDeque a doppio estremo

• removeFirst() - Restituisce ed elimina il primo elemento dall'ArrayDeque a doppio estremo (equivalente a remove())

• removeLast() - Restituisce ed elimina l'ultimo elemento dall'ArrayDeque a doppio estremo

Attenzione:Se l'ArrayDeque a doppio estremo è vuoto, i metodi remove(), removeFirst() e removeLast() sollevano un'eccezione. Inoltre, se non si trova l'elemento, remove(element) solleva un'eccezione.

For example,

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: \t" + animals);
　　　　　　　　//Utilizzare remove()
　　　　　　　　String element = animals.remove();
　　　　　　　　System.out.println("删除Element: " + element);
　　　　　　　　System.out.println("New ArrayDeque: \t" + animals);
　　　　　　　　//Utilizzare removeFirst()
　　　　　　　　String firstElement = animals.removeFirst();
　　　　　　　　System.out.println("Remove the first element: " + firstElement);
　　　　　　　　//Utilizzare removeLast()
　　　　　　　　String lastElement = animals.removeLast();
　　　　　　　　System.out.println("Remove the last element: " + lastElement);
　　　　}
}

Risultato di output

ArrayDeque: [Dog, Cat, Cow, Horse]
Remove Element: Dog
New ArrayDeque: [Cat, Cow, Horse]
Remove the first element: Cat
Remove the last element: Horse

2. Utilizzare i metodi poll(), pollFirst() e pollLast() per eliminare gli elementi

• poll() - Restituisce ed elimina il primo elemento dell'ArrayDeque a doppio estremo

• pollFirst() - Restituisce ed elimina il primo elemento dell'ArrayDeque a doppio estremo (equivalente a poll())

• pollLast() - Restituisce ed elimina l'ultimo elemento dell'ArrayDeque a doppio estremo

Attenzione:Se l'ArrayDeque a doppio estremo è vuoto, se non si trova l'elemento, poll(), pollFirst() e pollLast() restituiscono null.

For example,

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: \t" + animals);
　　　　　　　　//使用poll()
　　　　　　　　String element = animals.poll();
　　　　　　　　System.out.println("删除Element: " + element);
　　　　　　　　System.out.println("New ArrayDeque: \t" + animals);
　　　　　　　　//使用pollFirst()
　　　　　　　　String firstElement = animals.pollFirst();
　　　　　　　　System.out.println("Remove the first element: " + firstElement);
　　　　　　　　// Using pollLast()
　　　　　　　　String lastElement = animals.pollLast();
　　　　　　　　System.out.println("Remove the last element: " + lastElement);
　　　　}
}

Risultato di output

ArrayDeque: [Dog, Cat, Cow, Horse]
Remove Element: Dog
New ArrayDeque: [Cat, Cow, Horse]
Remove the first element: Cat
Remove the last element: Horse

3. Remove elements: Using the clear() method

To remove all elements from the ArrayDeque deque, we use the clear() method. For example,

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: \t" + animals);
　　　　　　　　// Using clear()
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("New ArrayDeque: \t" + animals);
　　　　}
}

Risultato di output

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

Iterating through ArrayDeque

• iterator() - Returns an iterator that can be used to traverse the ArrayDeque deque

• descendingIterator() - Returns an iterator that can be used to traverse the ArrayDeque deque in reverse order

To use these methods, we must import the java.util.Iterator package. For example,

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: \t");
　　　　　　　　// Using iterator()
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　System.out.print("\nArrayDeque in reverse: \t");
　　　　　　　　//Using descendingIterator()
　　　　　　　　Iterator<String> desIterate = animals.descendingIterator();
　　　　　　　　while(desIterate.hasNext()) {
　　　　　　　　　　　　System.out.print(desIterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Risultato di output

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

Other methods

ArrayDeque as a stack

To implement a stack in JavaLIFO (Last In, First Out)Stack, it is recommended to useStack classUsing a deque. The ArrayDeque class is faster than the Stack class.

ArrayDeque provides the following methods that can be used to implement a stack.

• push() - Adds an element to the top of the stack

• peek() - Returns an element from the top of the stack

• pop() - Returns and removes the element from the top of the stack

For example,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> stack = new ArrayDeque<>();
　　　　　　　　//Adding element to the stack
　　　　　　　　stack.push("Dog");
　　　　　　　　stack.push("Cat");
　　　　　　　　stack.push("Horse");
　　　　　　　　System.out.println("Stack: " + stack);
　　　　　　　　//Accessing element from the top of the stack
　　　　　　　　String element = stack.peek();
　　　　　　　　System.out.println("Accessing element: " + element);
　　　　　　　　//Elimina elemento dalla cima della pila
　　　　　　　　String　remElement　=　stack.pop();
　　　　　　　　System.out.println("Elimina element:　"　+　remElement);
　　　　}
}

Risultato di output

Stack:　[Horse,　Cat,　Dog]
Accedi all'elemento:　Horse
Elimina Elemento:　Horse

ArrayDeque e LinkedList classe

ArrayDeque eLinkedList di JavaImplementa l'interfaccia Deque. Tuttavia, ci sono alcune differenze tra loro.

• LinkedList supporta elementi vuoti, mentre ArrayDeque non lo fa.

• Ogni nodo della lista contiene un link a altri nodi. Questo è il motivo per cui LinkedList richiede più spazio di archiviazione rispetto a ArrayDeque.

• Se si desidera implementare la struttura dati di coda o deque, ArrayDeque potrebbe essere più veloce rispetto a LinkedList.