Dominando Java ArrayDeque: Guía Completa e Implementación de Pila

Java ArrayDeque

Esta guía explica la clase ArrayDeque, sus métodos y ejemplos prácticos—incluyendo cómo usarla como pila.

En Java, ArrayDeque implementa estructuras de datos cola y deque respaldadas por un array redimensionable.

---

Interfaces Implementadas por ArrayDeque

La clase ArrayDeque implementa las siguientes interfaces:

• Interfaz Queue de Java
• Interfaz Deque de Java

---

Creando un ArrayDeque

Primero importa el paquete:

import java.util.ArrayDeque;

Instancia un deque tipado:

ArrayDeque<Tipo> deque = new ArrayDeque<>();

Ejemplos:

// Deque de cadenas
ArrayDeque<String> animales = new ArrayDeque<>();
// Deque de enteros
ArrayDeque<Integer> edades = new ArrayDeque<>();

---

Métodos Clave de ArrayDeque

Insertando Elementos

1. Usando add(), addFirst(), addLast()

• add(E e) – añade e al final.
• addFirst(E e) – inserta e en la cabeza.
• addLast(E e) – equivalente a add().

Nota: Si el deque está lleno, estos métodos lanzan IllegalStateException.

ArrayDeque<String> animales = new ArrayDeque<>();
animales.add("Perro");
animales.addFirst("Gato");
animales.addLast("Caballo");
System.out.println("ArrayDeque: " + animales);

Salida

ArrayDeque: [Gato, Perro, Caballo]

2. Usando offer(), offerFirst(), offerLast()

• offer(E e) – añade e al final, devolviendo true si tiene éxito.
• offerFirst(E e) – inserta e en la cabeza.
• offerLast(E e) – igual que offer().

Nota: Estos métodos devuelven false si el deque está lleno.

ArrayDeque<String> animales = new ArrayDeque<>();
animales.offer("Perro");
animales.offerFirst("Gato");
animales.offerLast("Caballo");
System.out.println("ArrayDeque: " + animales);

Salida

ArrayDeque: [Gato, Perro, Caballo]

Accediendo a Elementos

1. getFirst() y getLast()

• getFirst() – devuelve el elemento de la cabeza.
• getLast() – devuelve el elemento de la cola.

Nota: Lanza NoSuchElementException si el deque está vacío.

ArrayDeque<String> animales = new ArrayDeque<>();
animales.add("Perro");
animales.add("Gato");
animales.add("Caballo");
System.out.println("ArrayDeque: " + animales);
System.out.println("Primer Elemento: " + animales.getFirst());
System.out.println("Último Elemento: " + animales.getLast());

Salida

ArrayDeque: [Perro, Gato, Caballo] Primer Elemento: Perro Último Elemento: Caballo

2. peek(), peekFirst(), peekLast()

• peek() – recupera pero no elimina la cabeza.
• peekFirst() – sinónimo de peek().
• peekLast() – recupera la cola.

ArrayDeque<String> animales = new ArrayDeque<>();
animales.add("Perro");
animales.add("Gato");
animales.add("Caballo");
System.out.println("ArrayDeque: " + animales);
System.out.println("Elemento Cabeza: " + animales.peek());
System.out.println("Primer Elemento: " + animales.peekFirst());
System.out.println("Último Elemento: " + animales.peekLast());

Salida

ArrayDeque: [Perro, Gato, Caballo] Elemento Cabeza: Perro Primer Elemento: Perro Último Elemento: Caballo

Nota: Si el deque está vacío, peek() y similares devuelven null en lugar de lanzar excepción.

Eliminando Elementos

1. remove(), removeFirst(), removeLast()

• remove() – elimina y devuelve la cabeza.
• removeFirst() – igual que remove().
• removeLast() – elimina y devuelve la cola.
• remove(Object o) – elimina la primera ocurrencia de o si está presente.

Nota: Lanza NoSuchElementException si el deque está vacío o si remove(o) no encuentra o.

ArrayDeque<String> animales = new ArrayDeque<>();
animales.add("Perro");
animales.add("Gato");
animales.add("Vaca");
animales.add("Caballo");
System.out.println("ArrayDeque: " + animales);
System.out.println("Elemento Eliminado: " + animales.remove());
System.out.println("Nuevo ArrayDeque: " + animales);
System.out.println("Primer Elemento Eliminado: " + animales.removeFirst());
System.out.println("Último Elemento Eliminado: " + animales.removeLast());

Salida

ArrayDeque: [Perro, Gato, Vaca, Caballo] Elemento Eliminado: Perro Nuevo ArrayDeque: [Gato, Vaca, Caballo] Primer Elemento Eliminado: Gato Último Elemento Eliminado: Caballo

2. poll(), pollFirst(), pollLast()

• poll() – elimina y devuelve la cabeza, o null si está vacío.
• pollFirst() – sinónimo de poll().
• pollLast() – elimina y devuelve la cola.

ArrayDeque<String> animales = new ArrayDeque<>();
animales.add("Perro");
animales.add("Gato");
animales.add("Vaca");
animales.add("Caballo");
System.out.println("ArrayDeque: " + animales);
System.out.println("Elemento Eliminado: " + animales.poll());
System.out.println("Nuevo ArrayDeque: " + animales);
System.out.println("Primer Elemento Eliminado: " + animales.pollFirst());
System.out.println("Último Elemento Eliminado: " + animales.pollLast());

Salida

ArrayDeque: [Perro, Gato, Vaca, Caballo] Elemento Eliminado: Perro Nuevo ArrayDeque: [Gato, Vaca, Caballo] Primer Elemento Eliminado: Gato Último Elemento Eliminado: Caballo

3. clear()

Vacía completamente el deque.

ArrayDeque<String> animales = new ArrayDeque<>();
animales.add("Perro");
animales.add("Gato");
animales.add("Caballo");
System.out.println("ArrayDeque: " + animales);
animales.clear();
System.out.println("Nuevo ArrayDeque: " + animales);

Salida

ArrayDeque: [Perro, Gato, Caballo] Nuevo ArrayDeque: []

Iterando sobre un ArrayDeque

• iterator() – iterador hacia adelante.
• descendingIterator() – iterador inverso.

ArrayDeque<String> animales = new ArrayDeque<>();
animales.add("Perro");
animales.add("Gato");
animales.add("Caballo");
System.out.print("ArrayDeque: ");
Iterator<String> it = animales.iterator();
while(it.hasNext()) {
    System.out.print(it.next() + ", ");
}
System.out.print("\nArrayDeque en orden inverso: ");
Iterator<String> rev = animales.descendingIterator();
while(rev.hasNext()) {
    System.out.print(rev.next() + ", ");
}

Salida

ArrayDeque: [Perro, Gato, Caballo] ArrayDeque en orden inverso: [Caballo, Gato, Perro]

Otros Métodos Comunes

Método	Descripción
element()	Recupera pero no elimina la cabeza.
contains(Object o)	Verifica la presencia de o; devuelve true si se encuentra.
size()	Número de elementos en el deque.
toArray()	Convierte el deque a un array.
clone()	Crea una copia superficial del deque.

Usando ArrayDeque como Pila (Stack)

Para comportamiento LIFO, ArrayDeque es preferible sobre Stack debido a mejor rendimiento y sin sobrecarga de sincronización heredada.

Métodos estilo pila:

• push(E e) – añade a la cabeza.
• peek() – recupera el elemento superior sin eliminarlo.
• pop() – elimina y devuelve el elemento superior.

ArrayDeque<String> pila = new ArrayDeque<>();
pila.push("Perro");
pila.push("Gato");
pila.push("Caballo");
System.out.println("Pila: " + pila);
System.out.println("Elemento Accedido: " + pila.peek());
System.out.println("Elemento Eliminado: " + pila.pop());

Salida

Pila: [Caballo, Gato, Perro] Elemento Accedido: Caballo Elemento Eliminado: Caballo

ArrayDeque vs LinkedList

Ambos implementan Deque, pero difieren:

• LinkedList permite elementos null; ArrayDeque no.
• Los nodos de LinkedList almacenan punteros, consumiendo más memoria.
• Para cargas de trabajo de cola/deque, ArrayDeque típicamente supera a LinkedList.