ArrayDeque in Java

Interfaces Implemented by ArrayDeque

The ArrayDeque class implements these two interfaces:

Queue Interface: The components are inserted from the rear of the queue interface, which is a FirstIn – FirstOut Data Structure.

Deque Interface: This is a Double-Ended Queue in which components can be inserted from both sides. It is a Queue implementation interface.

Java ArrayDeque Class Constructors

The constructors defined by the ArrayDeque class are as follows: 

Methods of ArrayDeque in Java

In Java, ArrayDeque introduces no new methods. All the methods are inherited by Deque, Queue, and Collection interface. The following are the most important methods:

Also see,  Swap Function in Java

Examples of ArrayDeque Class

1. Addition of Elements

Let's write a programme that adds items to the ArrayDeque using methods like add(), addFirst(), addLast(), offer(), offerFirst(), offerLast(), and offerLast().

Example

• Java

Java

import java.util.ArrayDeque;
public class SampleArrayDeque {
public static void main(String[] args)
{
// Create object of ArrayDeque class of String type.  
  ArrayDeque<Integer> dq = new ArrayDeque<Integer>();


// Adding elements to deque using add() method.
    dq.add(30);
    dq.addFirst(50);
    dq.addLast(07);


// Adding elements to deque using offer() method.  
    dq.offer(60);
    dq.offerFirst(80);
    dq.offerLast(70);


System.out.println("Elements in ArrayDeque are : " + dq);
 }
}

You can also try this code with Online Java Compiler

Run Code

Output

Elements in ArrayDeque are : [80, 50, 30, 7, 60, 70]

Practice by yourself on online java compiler.

2. Accessing the Elements

Let's write a program that uses methods like getFirst(), getLast(), and so on to access items.

Example

• Java

Java

import java.util.ArrayDeque;
public class SampleArrayDeque {
    public static void main(String[] args) {
        ArrayDeque<String> flowers= new ArrayDeque<>();
        
        flowers.add("Sunflower");
        flowers.add("Rose");
        flowers.add("Lily");
        System.out.println("ArrayDeque: " + flowers);
        
        // Get the first element
        String firstElement = flowers.getFirst();
        System.out.println("First Element: " + firstElement);
        
        // Get the last element
        String lastElement = flowers.getLast();
        System.out.println("Last Element: " + lastElement);
    }
}

You can also try this code with Online Java Compiler

Run Code

Output

ArrayDeque: [Sunflower, Rose, Lily]
First Element: Sunflower
Last Element: Lily

3. Removing Elements

Let's write a program that removes an element from a deque using various methods such as removeFirst(), removeLast(), poll(), pop(), pollFirst(), pollLast().

Example

• Java

Java

import java.util.ArrayDeque;
public class  SampleArrayDeque{
    public static void main(String[] args) {
        ArrayDeque<String> Elements= new ArrayDeque<>();
        Elements.add("Element1");
        Elements.add("Element2");
        Elements.add("Element3");
        Elements.add("Element4");
        System.out.println("ArrayDeque: " + Elements);

        // Using remove()
        String element = Elements.remove();
        System.out.println("Removed Element: " + element);

        System.out.println("New ArrayDeque: " + Elements);
        // Using removeFirst()
        String firstElement = Elements.removeFirst();
        System.out.println("Removed First Element: " + firstElement);


        // Using removeLast()
        String lastElement = Elements.removeLast();
        System.out.println("Removed Last Element: " + lastElement);
    }
}

You can also try this code with Online Java Compiler

Run Code

Output

ArrayDeque: [Element1, Element2, Element3, Element4]
Removed Element: Element1
New ArrayDeque: [Element2, Element3, Element4]
Removed First Element: Element2
Removed Last Element: Element4

4. Iterating through the Deque

ArrayDeque's iterator() and descendingIterator() methods may loop through elements from both ends of the deque. Take a look at the raw code below.

Example

• Java

Java

import java.util.ArrayDeque;
import java.util.Iterator;
public class  SampleArrayDeque {
    public static void main(String[] args) {
        ArrayDeque<String> numbers= new ArrayDeque<>();
        numbers.add("One");
        numbers.add("Two");
        numbers.add("Three");

        System.out.print("ArrayDeque: ");

        // Using iterator()
        Iterator<String> iterate = numbers.iterator();
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }

        System.out.print("\nArrayDeque in reverse order: ");
        // Using descendingIterator()
        Iterator<String> desIterate = numbers.descendingIterator();
        while(desIterate.hasNext()) {
            System.out.print(desIterate.next());
            System.out.print(", ");
        }
    }
}

You can also try this code with Online Java Compiler

Run Code

Output

ArrayDeque: One, Two, Three,
ArrayDeque in reverse order: Three, Two, One,

5. ArrayDeque as a Stack

It is advised to use a deque over the Stack class to implement LIFO (Last-In-First-Out) stacks in Java. The ArrayDeque class will almost certainly be faster than the Stack class.

ArrayDeque provides methods like push(), peek(), pop() for implementing a stack.

Example

• Java

Java

import java.util.ArrayDeque;

public class  SampleArrayDeque {
    public static void main(String[] args) {
        ArrayDeque<String> stack = new ArrayDeque<>();

        // Add elements to stack
        stack.push("Ele1");
        stack.push("Ele2");
        stack.push("Ele3");
        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);
    }
}

You can also try this code with Online Java Compiler

Run Code

Output

Stack: [Ele3, Ele2, Ele1]
Accessed Element: Ele3
Removed element: Ele3

Advantages of Using ArrayDeque

• Faster Performance for Adding/Removing Elements: ArrayDeque provides faster add and remove operations for both ends (front and rear), as it does not require resizing as frequently as an array-based list.
• No Capacity Limit: ArrayDeque dynamically grows in size as needed, unlike ArrayList or arrays, which are limited by their initial capacity. This ensures it can handle a large number of elements efficiently.
• Improved Memory Efficiency: Unlike LinkedList, which uses more memory due to the storage of pointers in each node, ArrayDeque uses contiguous memory, resulting in less memory overhead.
• Supports Both Stack and Queue Operations: ArrayDeque can be used as a stack (LIFO) or a queue (FIFO), making it versatile for various use cases, such as in breadth-first or depth-first search algorithms.
• Thread-Safety (with External Synchronization): Although ArrayDeque is not thread-safe, its operations are generally faster than other thread-safe collections like ConcurrentLinkedQueue, especially when external synchronization is used.

Disadvantages of Using ArrayDeque

• Not Thread-Safe: ArrayDeque is not inherently thread-safe, meaning external synchronization is required when used in multi-threaded environments, adding complexity and overhead.
• No Support for Null Elements: Unlike some other collections like ArrayList, ArrayDeque does not allow storing null elements, which can be limiting in certain scenarios.
• Memory Wastage in Certain Scenarios: When an ArrayDeque is dynamically resized, it might allocate more memory than needed, potentially wasting memory when the number of elements decreases significantly after growth.
• Resizing Overhead: While ArrayDeque grows dynamically, resizing can incur overhead, especially when a large number of elements are added in rapid succession.
• Not Ideal for Random Access: ArrayDeque does not support efficient random access to elements like an ArrayList or Vector because it is designed to be efficient for queue-like or stack-like operations.

Frequently Asked Questions

What is the difference between Deque and ArrayDeque?

At both ends, the Deque interface provides element insertion, removal, and retrieval. The ArrayDeque class implements the Deque interface as a resizeable array, whereas the LinkedList class implements it as a list.

Can we add null in ArrayDeque?

Null cannot be used in an ArrayDeque because functions such as poll() use null as a special return value to signal that the collection is empty. Because null has that meaning, Java bans you from placing one in there.

Does ArrayDeque implement list?

ArrayDeque does not implement List.

Is ArrayDeque better than stack?

ArrayDeque and Stack serve different purposes. While Stack is a legacy class focused on LIFO (Last In, First Out) operations, ArrayDeque offers more functionality like resizable capacity, making it more versatile and efficient for general deque operations.

What is the difference between ArrayDeque and ArrayList?

ArrayDeque is a resizable array implementation of a deque, optimized for adding and removing elements from both ends, whereas ArrayList is a dynamic array designed for random access to elements and adding/removing elements at the end, with slower operations for the beginning.

Conclusion

ArrayDeque in Java is a highly efficient data structure for handling scenarios that require fast insertion and removal of elements from both ends of the queue. Its dynamic resizing, improved memory efficiency, and versatile functionality for stack and queue operations make it a strong choice for many applications.

Recommended problems -

• Product Array Puzzle
• Beautiful Array
• Reverse a Stack using Recursion
   

We hope that this blog has helped you enhance your knowledge of the ArrayDeque class in java and if you would like to learn more about java, check out our articles, java archives, 

• Priority Queue in Java
• Duck Number in Java
• Hashcode Method in Java