Java Array Deque

Java ArrayDeque

Neste tutorial, aprenderemos sobre a classe ArrayDeque e seus métodos com a ajuda de exemplos. Além disso, aprenderemos a usar o array deque para implementar uma pilha.

Em Java, podemos usar o ArrayDeque class para implementar estruturas de dados queue e deque usando arrays.

---

Interfaces implementadas por ArrayDeque

O ArrayDeque class implementa essas duas interfaces:

• Interface de fila Java
• Interface Java Deque

---

Criando ArrayDeque

Para criar um array deque, devemos importar o java.util.ArrayDeque pacote.

Aqui está como podemos criar um array deque em Java:

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

Aqui, Digite indica o tipo do array deque. Por exemplo,

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

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

---

Métodos de ArrayDeque

O ArrayDeque classe fornece implementações para todos os métodos presentes em Queue e Deque interface.

---

Inserir Elementos para Deque

1. Adicione elementos usando add(), addFirst() e addLast()

• add() - insere o elemento especificado no final do array deque
• addFirst() - insere o elemento especificado no início do array deque
• addLast() - insere o especificado no final do array deque (equivalente a add() )

Observação: Se o array deque estiver cheio, todos esses métodos add() , addFirst() e addLast() lança IllegalStateException .

Por exemplo,

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);
    }
}

Saída

ArrayDeque: [Cat, Dog, Horse]

2. Insira elementos usando offer(), offerFirst() e offerLast()

• offer() - insere o elemento especificado no final do array deque
• offerFirst() - insere o elemento especificado no início do array deque
• offerLast() - insere o elemento especificado no final do array deque

Observação: offer() , offerFirst() e offerLast() retorna true se o elemento for inserido com sucesso; se o array deque estiver cheio, esses métodos retornarão false .

Por exemplo,

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);
    }
}

Saída

ArrayDeque: [Cat, Dog, Horse]

Observação: Se a matriz deque estiver cheia

• o add() método lançará uma exceção
• os offer() método retorna false

---

Acessar elementos ArrayDeque

1. Acessar elementos usando getFirst() e getLast()

• getFirst() - retorna o primeiro elemento do array deque
• getLast() - retorna o último elemento do array deque

Observação: Se o array deque estiver vazio, getFirst() e getLast() lança 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);

        // 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);
    }
}

Saída

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

2. Acessar elementos usando o método peek(), peekFirst() e peekLast()

• peek() - retorna o primeiro elemento do array deque
• peekFirst() - retorna o primeiro elemento do array deque (equivalente a peek() )
• peekLast() - retorna o último elemento do array deque

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);

        // 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);
    }
}

Saída

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

Observação: Se o array deque estiver vazio, peek() , peekFirst() e getLast() lança NoSuchElementException .

---

Remover elementos ArrayDeque

1. Remova elementos usando o método remove(), removeFirst(), removeLast()

• remove() - retorna e remove um elemento do primeiro elemento do array deque
• remove(element) - retorna e remove o elemento especificado do cabeçalho do array deque
• removeFirst() - retorna e remove o primeiro elemento do array deque (equivalente a remove() )
• removeLast() - retorna e remove o último elemento do array deque

Observação: Se o array deque estiver vazio, remove() , removeFirst() e removeLast() método lança uma exceção. Além disso, remove(element) lança uma exceção se o elemento não for encontrado.

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("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);
    }
}

Saída

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

2. Remova elementos usando o método poll(), pollFirst() e pollLast()

• poll() - retorna e remove o primeiro elemento do array deque
• pollFirst() - retorna e remove o primeiro elemento do array deque (equivalente a poll() )
• pollLast() - retorna e remove o último elemento do array deque

Observação: Se o array deque estiver vazio, poll() , pollFirst() e pollLast() retorna null se o elemento não for encontrado.

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("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);
    }
}

Saída

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

3. Remover elemento:usando o método clear()

Para remover todos os elementos do array deque, usamos o clear() método. 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);

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

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

Saída

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

---

Iterando o ArrayDeque

• iterator() - retorna um iterador que pode ser usado para iterar sobre o array deque
• descendingIterator() - retorna um iterador que pode ser usado para iterar sobre o array deque na ordem inversa

Para usar esses métodos, devemos importar o java.util.Iterator pacote. 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: ");

        // 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(", ");
        }
    }
}

Saída

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

---

Outros métodos

Métodos	Descrições
element()	Retorna um elemento do cabeçalho do array deque.
contains(element)	Pesquisa a matriz deque para o elemento especificado. Se o elemento for encontrado, ele retornará true , caso contrário, retornará false .
size()	Retorna o comprimento do array deque.
toArray()	Converte array deque em array e o retorna.
clone()	Cria uma cópia do array deque e a retorna.

---

ArrayDeque como uma pilha

Para implementar um LIFO (Last-In-First-Out) stacks em Java, é recomendado usar um deque sobre a classe Stack. O ArrayDeque é provável que a classe seja mais rápida que a Stack classe.

ArrayDeque fornece os seguintes métodos que podem ser usados ​​para implementar uma pilha.

• push() - adiciona um elemento ao topo da pilha
• peek() - retorna um elemento do topo da pilha
• pop() - retorna e remove um elemento do topo da pilha

Por exemplo,

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);
    }
}

Saída

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

---

ArrayDeque vs. Classe LinkedList

Ambos ArrayDeque e Java LinkedList implementa o Deque interface. No entanto, existem algumas diferenças entre eles.

• LinkedList suporta null elementos, enquanto ArrayDeque não.
• Cada nó em uma lista vinculada inclui links para outros nós. É por isso que LinkedList requer mais armazenamento do que ArrayDeque .
• Se você estiver implementando a estrutura de dados queue ou deque, um ArrayDeque é provável que seja mais rápido que um LinkedList .