ArrayDeque Java

Neste tutorial, vamos aprender a classe ArrayDeque e seus métodos através de exemplos. Além disso, também vamos aprender a implementar pilhas usando ArrayDeque.

No Java, podemos usar a classe ArrayDeque para implementar a estrutura de dados de fila e deque usando arrays.

Interfaces implementadas pelo ArrayDeque

A classe ArrayDeque implementa essas duas interfaces:

• Interface Java Queue

• Interface Deque Java

Criar ArrayDeque

Para criar a fila de ArrayDeque, devemos importar o pacote java.util.ArrayDeque.

Aqui estão os métodos que podemos usar no Java para criar a fila de ArrayDeque:

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

Aqui, Type representa o tipo da fila de ArrayDeque. Por exemplo,

//Criar ArrayDeque de tipo string
ArrayDeque<String> animals = new ArrayDeque<>();
//Criar ArrayDeque de tipo inteiro
ArrayDeque<Integer> age = new ArrayDeque<>();

Métodos de ArrayDeque

A classe ArrayDeque oferece todos os métodos existentes nas interfaces Queue e Deque.

Inserir o elemento na fila de ArrayDeque

1.Usar add(), addFirst() e addLast() para adicionar elementos

• add() - Insere o elemento especificado no final da ArrayDeque

• addFirst() -Inserir o elemento especificado no início da fila de ArrayDeque

• addLast() - Inserir o conteúdo especificado no final da fila de ArrayDeque (equivalente a add())

Atenção:Se a fila de ArrayDeque estiver cheia, todos esses métodos add(), addFirst() e addLast() gerarão a exceção IllegalStateException.

Por exemplo,

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

Resultado de Saída

ArrayDeque: [Gato, Cão, Cavalo]

2.Usar offer(), offerFirst() e offerLast() para inserir elementos

• offer() - Insere o elemento especificado no final da ArrayDeque

• offerFirst() - Insere o elemento especificado no início da ArrayDeque

• offerLast() - Insere o elemento especificado no final da ArrayDeque

Atenção: offer(), offerFirst() e offerLast() retornam true se o elemento for inserido com sucesso; caso contrário, retornam. Se a ArrayDeque estiver cheia, essas métodos retornam false.

Por exemplo,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> animals = new ArrayDeque<>();
　　　　　　　　//Usando offer()
　　　　　　　　animals.offer("Cão");
　　　　　　　　//Usando offerFirst()
　　　　　　　　animals.offerFirst("Gato");
　　　　　　　　//Usando offerLast()
　　　　　　　　animals.offerLast("Cavalo");
　　　　　　　　System.out.println("ArrayDeque: ");　+　animals);
　　　　}
}

Resultado de Saída

ArrayDeque: [Gato, Cão, Cavalo]

Acessar elementos da ArrayDeque

1.Usando getFirst() e getLast() para acessar elementos

• getFirst() - Retorna o primeiro elemento da ArrayDeque

• getLast() - Retorna o último elemento da ArrayDeque

Nota:Se a ArrayDeque estiver vazia, getFirst() e getLast() lançam NoSuchElementException.

Por exemplo,

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);
　　　　　　　　//　Obtém o primeiro elemento
　　　　　　　　String firstElement = animals.getFirst();
　　　　　　　　System.out.println("Primeiro elemento: " + "\t"　+　firstElement);
　　　　　　　　//Obtém o último elemento
　　　　　　　　String lastElement = animals.getLast();
　　　　　　　　System.out.println("Último elemento: " + "\t"　+　lastElement);
　　　　}
}

Resultado de Saída

ArrayDeque: [Dog, Cat, Horse]
Primeiro elemento: 	Cão
Último elemento: 	Cavalo

2.Usando peek(), peekFirst() e peekLast() para acessar elementos

• peek() - Retorna o primeiro elemento da ArrayDeque

• peekFirst() - Retorna o primeiro elemento da ArrayDeque (equivalente a peek())

• peekLast() - Retorna o último elemento da ArrayDeque

Por exemplo,

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);
　　　　　　　　//Usando peek()
　　　　　　　　String element = animals.peek();
　　　　　　　　System.out.println("Elemento inicial: " + "\t"　+　element);
　　　　　　　　//Usando peekFirst()
　　　　　　　　String firstElement = animals.peekFirst();
　　　　　　　　System.out.println("Primeiro elemento: " + "\t"　+　firstElement);
　　　　　　　　//Usando peekLast
　　　　　　　　String lastElement = animals.peekLast();
　　　　　　　　System.out.println("Último elemento: " + "\t"　+　lastElement);
　　　　}
}

Resultado de Saída

ArrayDeque: [Dog, Cat, Horse]
Elemento de cabeça: 	Cão
Primeiro elemento: 	Cão
Último elemento: 	Cavalo

Atenção:Se a ArrayDeque do deque duplo estiver vazia, peek(), peekFirst() e getLast() lançam NoSuchElementException.

Remover elemento ArrayDeque

1.Usar os métodos remove(), removeFirst(), removeLast() para remover elementos

• remove() - Retorna e remove um elemento da primeira elemento da ArrayDeque do deque duplo

• remove(element) - Retorna e remove o elemento especificado da cabeça da ArrayDeque do deque duplo

• removeFirst() - Retorna e remove o primeiro elemento da ArrayDeque do deque duplo (equivalente a remove())

• removeLast() - Retorna e remove o último elemento da ArrayDeque do deque duplo

Atenção:Se a ArrayDeque do deque duplo estiver vazia, os métodos remove(), removeFirst() e removeLast() levantam uma exceção. Além disso, se não encontrar o elemento, remove(element) levanta uma exceção.

Por exemplo,

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("Vaca");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayDeque: ");　+　animals);
　　　　　　　　//Usar remove()
　　　　　　　　String element = animals.remove();
　　　　　　　　System.out.println("Remover Elemento: ")　+　element);
　　　　　　　　System.out.println("Nova ArrayDeque: ");　+　animals);
　　　　　　　　//Usar removeFirst()
　　　　　　　　String firstElement = animals.removeFirst();
　　　　　　　　System.out.println("Remoção do primeiro elemento: ");　+　firstElement);
　　　　　　　　//Usar removeLast()
　　　　　　　　String lastElement = animals.removeLast();
　　　　　　　　System.out.println("Remoção do último elemento: ");　+　lastElement);
　　　　}
}

Resultado de Saída

ArrayDeque: [Dog, Cat, Cow, Horse]
Remoção do Elemento: Dog
Nova ArrayDeque: [Cat, Cow, Horse]
Remoção do primeiro elemento: Cat
Remoção do último elemento: Horse

2.Usar os métodos poll(), pollFirst() e pollLast() para remover elementos

• poll() - Retorna e remove o primeiro elemento da ArrayDeque do deque duplo

• pollFirst() - Retorna e remove o primeiro elemento da ArrayDeque do deque duplo (equivalente a poll())

• pollLast() - Retorna e remove o último elemento da ArrayDeque do deque duplo

Atenção:Se a ArrayDeque do deque duplo estiver vazia, se não encontrar o elemento, poll(), pollFirst() e pollLast() retornam null.

Por exemplo,

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("Vaca");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayDeque: ");　+　animals);
　　　　　　　　//Usar poll()
　　　　　　　　String element = animals.poll();
　　　　　　　　System.out.println("Remover Elemento: ")　+　element);
　　　　　　　　System.out.println("Nova ArrayDeque: ");　+　animals);
　　　　　　　　//Usar pollFirst()
　　　　　　　　String firstElement = animals.pollFirst();
　　　　　　　　System.out.println("Remoção do primeiro elemento: ");　+　firstElement);
　　　　　　　　//Usando pollLast()
　　　　　　　　String lastElement = animals.pollLast();
　　　　　　　　System.out.println("Remoção do último elemento: ");　+　lastElement);
　　　　}
}

Resultado de Saída

ArrayDeque: [Dog, Cat, Cow, Horse]
Remoção do Elemento: Dog
Nova ArrayDeque: [Cat, Cow, Horse]
Remoção do primeiro elemento: Cat
Remoção do último elemento: Horse

3.Remoção de elementos: usando o método clear()

Para remover todos os elementos da ArrayDeque bidirecional, usamos o método clear(). Por exemplo,

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);
　　　　　　　　//Usando clear()
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("Nova ArrayDeque: ");　+　animals);
　　　　}
}

Resultado de Saída

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

Iteração na ArrayDeque

• iterator() - Retorna um iterador que pode ser usado para percorrer a ArrayDeque bidirecional

• descendingIterator() -Retorna um iterador que pode ser usado para percorrer a ArrayDeque bidirecional em ordem inversa

Para usar esses métodos, devemos importar o pacote java.util.Iterator. Por exemplo,

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

Resultado de Saída

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

Outros métodos

ArrayDeque como pilha

Para implementar em JavaLIFO (último a entrar, primeiro a sair)Pilha, recomenda-se usarClasse StackUsar fila dupla no topo. A ArrayDeque é mais rápida que a classe Stack.

ArrayDeque oferece os seguintes métodos que podem ser usados para implementar pilhas.

• push() - Adicionar um elemento no topo da pilha

• peek() - Retornar um elemento do topo da pilha

• pop() - Retornar e remover elemento do topo da pilha

Por exemplo,

import java.util.ArrayDeque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayDeque<String> stack = new ArrayDeque<>();
　　　　　　　　//Adicionar elemento ao stack
　　　　　　　　stack.push("Dog");
　　　　　　　　stack.push("Cat");
　　　　　　　　stack.push("Horse");
　　　　　　　　System.out.println("Pilha: "　+　stack);
　　　　　　　　//Acessar elemento do topo da pilha
　　　　　　　　String element = stack.peek();
　　　　　　　　System.out.println("Acessar elemento: "　+　element);
　　　　　　　　//Remover elemento da parte superior da pilha
　　　　　　　　String remElement = stack.pop();
　　　　　　　　System.out.println("Remover elemento: ",　+　remElement);
　　　　}
}

Resultado de Saída

Pilha:　[Horse,　Cat,　Dog]
Acessar Elemento:　Horse
Remover Elemento:　Horse

Classe ArrayDeque e LinkedList

ArrayDeque eLinkedList de JavaImplementa a interface Deque. No entanto, há algumas diferenças entre eles.

• LinkedList suporta elementos nulos, enquanto ArrayDeque não.

• Cada nó da lista encadeada contém uma referência para outros nós. Isso é a razão pela qual LinkedList precisa de mais espaço de armazenamento do que ArrayDeque.

• Se você quiser implementar a estrutura de dados de fila ou deque, ArrayDeque pode ser mais rápido do que LinkedList.