Java Deque Interface

Deque stands for Double Ended Queue.

It is a Java interface that allows elements to be added and removed from both the front and the rear of the queue.

       Front                     Rear
          ↓                        ↓
       [ A ] → [ B ] → [ C ] → [ D ]
          ↑                        ↑
       remove                    remove
       add                       add

Because elements can be manipulated at both ends, a Deque can be used as both:

• A Queue
• A Stack

Why Do We Need Deque?

A normal Queue generally focuses on operations at two ends:

• Add at the rear
• Remove from the front

A Deque provides more flexibility.

We can:

• Add at front
• Add at rear
• Remove from front
• Remove from rear
• Read front
• Read rear

Creating a Deque

Deque is an interface.

A common implementation is ArrayDeque.

Deque<String> deque = new ArrayDeque<>();

We can also use LinkedList:

Deque<String> deque = new LinkedList<>();

Adding Elements at the Front

Use:

deque.addFirst("A");

Example

Deque<String> deque = new ArrayDeque<>();
 
deque.addFirst("A");
deque.addFirst("B");
 
System.out.println(deque);

Output

[B, A]

Adding Elements at the Rear

Use:

deque.addLast("C");

Example

deque.addFirst("A");
deque.addLast("B");
deque.addLast("C");
 
System.out.println(deque);

Output

[A, B, C]

offerFirst() and offerLast()

Deque also provides:

deque.offerFirst("A");
deque.offerLast("B");

These return a boolean indicating whether insertion succeeded.

Removing from the Front

Use:

deque.removeFirst();

or:

deque.pollFirst();

The difference is what happens when the Deque is empty:

• removeFirst() throws an exception.
• pollFirst() returns null.

Removing from the Rear

Use:

deque.removeLast();

or:

deque.pollLast();

Reading Without Removing

Read the front:

deque.peekFirst();

Read the rear:

deque.peekLast();

Deque Method Groups

Example

import java.util.ArrayDeque;
import java.util.Deque;
 
public class HelloWorld {
    public static void main(String[] args) {
 
        Deque<String> deque = new ArrayDeque<>();
 
        deque.addFirst("B");
        deque.addLast("C");
        deque.addFirst("A");
 
        System.out.println(deque);
 
        System.out.println("First: " + deque.peekFirst());
        System.out.println("Last: " + deque.peekLast());
    }
}

Output

[A, B, C]
First: A
Last: C

Deque as a Queue

A Deque can behave like a normal FIFO queue.

Add elements at the rear:

deque.offerLast("A");
deque.offerLast("B");
deque.offerLast("C");

Remove from the front:

deque.pollFirst();

The processing order is:

A → B → C

Deque as a Stack

A Deque can also behave like a LIFO stack.

Use:

deque.push("A");
deque.push("B");
deque.push("C");

Then:

deque.pop();

returns:

C

The operations are:

push() → addFirst()
pop()  → removeFirst()
peek() → peekFirst()

Example: Deque as Stack

import java.util.ArrayDeque;
import java.util.Deque;
 
public class HelloWorld {
    public static void main(String[] args) {
 
        Deque<String> stack = new ArrayDeque<>();
 
        stack.push("Java");
        stack.push("Python");
        stack.push("C++");
 
        System.out.println(stack.pop());
    }
}

Output

C++

The last added element is removed first.

ArrayDeque Does Not Allow Null

ArrayDeque does not permit null elements. This is an implementation rule, not a ban on every Deque: LinkedList permits null, although using null in a queue or deque is discouraged.

Deque<String> deque = new ArrayDeque<>();
 
deque.add(null);

This results in an exception.

This restriction helps avoid ambiguity because methods such as poll() can use null to indicate that no element is available.

Deque Allows Duplicates

A Deque can contain duplicate elements.

Deque<String> deque = new ArrayDeque<>();
 
deque.add("Java");
deque.add("Java");

Both elements can be stored.

ArrayDeque

ArrayDeque is one of the most commonly used implementations of Deque.

Deque<Integer> numbers = new ArrayDeque<>();

It is designed for efficient operations at both ends.

It can be used as:

Queue
  +
Stack
  +
Double-ended queue

Deque vs Queue

Deque vs Stack

Example: Palindrome Check

A Deque can be useful for checking whether characters read the same from both ends.

import java.util.ArrayDeque;
import java.util.Deque;
 
public class HelloWorld {
 
    public static void main(String[] args) {
 
        String word = "level";
 
        Deque<Character> deque = new ArrayDeque<>();
 
        for (char ch : word.toCharArray()) {
            deque.addLast(ch);
        }
 
        boolean palindrome = true;
 
        while (deque.size() > 1) {
 
            if (deque.pollFirst()
                    .charValue() != deque.pollLast()
                    .charValue()) {
 
                palindrome = false;
                break;
            }
        }
 
        System.out.println("Palindrome: " + palindrome);
    }
}

Output

Palindrome: true

When Should You Use Deque?

Use a Deque when:

• Elements need to be added or removed from both ends.
• You need queue behavior.
• You need stack behavior.
• You need efficient front and rear operations.

Common examples include:

• Sliding-window algorithms
• Queue processing
• Stack implementation
• Palindrome checking
• Breadth-first or depth-related processing patterns

Important Points

• Deque means Double Ended Queue.

It allows operations at both ends. ArrayDeque is a common implementation. LinkedList can also implement Deque. A Deque can behave like a Queue. A Deque can behave like a Stack. ArrayDeque does not permit null. Duplicate elements are allowed.

Key Takeaway

Deque provides flexible operations at both ends of a collection. It can be used as a FIFO Queue, a LIFO Stack, or a true double-ended queue. For many stack use cases in modern Java, ArrayDeque is preferred over the legacy Stack class.