Mastering Java ArrayDeque: Comprehensive Guide & Stack Implementation

Java ArrayDeque

This guide explains the ArrayDeque class, its methods, and practical examples—including how to use it as a stack.

In Java, ArrayDeque implements queue and deque data structures backed by a resizable array.

---

Interfaces Implemented by ArrayDeque

The ArrayDeque class implements the following interfaces:

• Java Queue Interface
• Java Deque Interface

---

Creating an ArrayDeque

First import the package:

import java.util.ArrayDeque;

Instantiate a typed deque:

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

Examples:

// String deque
ArrayDeque<String> animals = new ArrayDeque<>();

// Integer deque
ArrayDeque<Integer> ages = new ArrayDeque<>();

---

Key ArrayDeque Methods

Inserting Elements

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

• add(E e) – appends e to the tail.
• addFirst(E e) – inserts e at the head.
• addLast(E e) – equivalent to add().

Note: If the deque is full, these methods throw IllegalStateException.

ArrayDeque<String> animals = new ArrayDeque<>();
animals.add("Dog");
animals.addFirst("Cat");
animals.addLast("Horse");
System.out.println("ArrayDeque: " + animals);

Output

ArrayDeque: [Cat, Dog, Horse]

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

• offer(E e) – appends e to the tail, returning true on success.
• offerFirst(E e) – inserts e at the head.
• offerLast(E e) – same as offer().

Note: These methods return false if the deque is full.

ArrayDeque<String> animals = new ArrayDeque<>();
animals.offer("Dog");
animals.offerFirst("Cat");
animals.offerLast("Horse");
System.out.println("ArrayDeque: " + animals);

Output

ArrayDeque: [Cat, Dog, Horse]

Accessing Elements

1. getFirst() and getLast()

• getFirst() – returns the head element.
• getLast() – returns the tail element.

Note: Throws NoSuchElementException if the deque is empty.

ArrayDeque<String> animals = new ArrayDeque<>();
animals.add("Dog");
animals.add("Cat");
animals.add("Horse");
System.out.println("ArrayDeque: " + animals);
System.out.println("First Element: " + animals.getFirst());
System.out.println("Last Element: " + animals.getLast());

Output

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

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

• peek() – retrieves but does not remove the head.
• peekFirst() – synonym for peek().
• peekLast() – retrieves the tail.

ArrayDeque<String> animals = new ArrayDeque<>();
animals.add("Dog");
animals.add("Cat");
animals.add("Horse");
System.out.println("ArrayDeque: " + animals);
System.out.println("Head Element: " + animals.peek());
System.out.println("First Element: " + animals.peekFirst());
System.out.println("Last Element: " + animals.peekLast());

Output

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

Note: If the deque is empty, peek() and friends return null instead of throwing.

Removing Elements

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

• remove() – removes and returns the head.
• removeFirst() – same as remove().
• removeLast() – removes and returns the tail.
• remove(Object o) – removes the first occurrence of o if present.

Note: Throws NoSuchElementException if the deque is empty or if remove(o) cannot find o.

ArrayDeque<String> animals = new ArrayDeque<>();
animals.add("Dog");
animals.add("Cat");
animals.add("Cow");
animals.add("Horse");
System.out.println("ArrayDeque: " + animals);
System.out.println("Removed Element: " + animals.remove());
System.out.println("New ArrayDeque: " + animals);
System.out.println("Removed First Element: " + animals.removeFirst());
System.out.println("Removed Last Element: " + animals.removeLast());

Output

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

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

• poll() – removes and returns the head, or null if empty.
• pollFirst() – synonym for poll().
• pollLast() – removes and returns the tail.

ArrayDeque<String> animals = new ArrayDeque<>();
animals.add("Dog");
animals.add("Cat");
animals.add("Cow");
animals.add("Horse");
System.out.println("ArrayDeque: " + animals);
System.out.println("Removed Element: " + animals.poll());
System.out.println("New ArrayDeque: " + animals);
System.out.println("Removed First Element: " + animals.pollFirst());
System.out.println("Removed Last Element: " + animals.pollLast());

Output

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

3. clear()

Empties the entire deque.

ArrayDeque<String> animals = new ArrayDeque<>();
animals.add("Dog");
animals.add("Cat");
animals.add("Horse");
System.out.println("ArrayDeque: " + animals);
animals.clear();
System.out.println("New ArrayDeque: " + animals);

Output

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

Iterating Over an ArrayDeque

• iterator() – forward iterator.
• descendingIterator() – reverse iterator.

ArrayDeque<String> animals = new ArrayDeque<>();
animals.add("Dog");
animals.add("Cat");
animals.add("Horse");
System.out.print("ArrayDeque: ");
Iterator<String> it = animals.iterator();
while(it.hasNext()) {
    System.out.print(it.next() + ", ");
}
System.out.print("\nArrayDeque in reverse order: ");
Iterator<String> rev = animals.descendingIterator();
while(rev.hasNext()) {
    System.out.print(rev.next() + ", ");
}

Output

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

Other Common Methods

Method	Description
element()	Retrieves but does not remove the head.
contains(Object o)	Checks for the presence of o; returns true if found.
size()	Number of elements in the deque.
toArray()	Converts the deque to an array.
clone()	Creates a shallow copy of the deque.

Using ArrayDeque as a Stack

For LIFO behavior, ArrayDeque is preferable over Stack due to better performance and no legacy synchronization overhead.

Stack‑style methods:

• push(E e) – adds to the head.
• peek() – retrieves the top element without removal.
• pop() – removes and returns the top element.

ArrayDeque<String> stack = new ArrayDeque<>();
stack.push("Dog");
stack.push("Cat");
stack.push("Horse");
System.out.println("Stack: " + stack);
System.out.println("Accessed Element: " + stack.peek());
System.out.println("Removed Element: " + stack.pop());

Output

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

ArrayDeque vs LinkedList

Both implement Deque, yet they differ:

• LinkedList allows null elements; ArrayDeque does not.
• LinkedList nodes store pointers, consuming more memory.
• For queue/deque workloads, ArrayDeque typically outperforms LinkedList.