Queue, Deque, Arraydeque, Priorityqueue In Java

Java Functions And Methods

Java Foundation

Java Flow Control

Java Inner Classes

Java 8 Features

Java File I/o

Java Multithreading

Java Arrays And Strings

Java Exception Handling

Java Classes

Java OOP's

Java Collections Framework

Queue interface, Deque interface, ArrayDeque class & PriorityQueue class

Dont worry we study this hirarchy one by one, first you understand these points.

ArrayDeque implements Deque extends Queue.
LinkedList implements Deque extends Queue.
PriorityQueue implements Queue.

Now see the below image.

Queue interface

Queue:

The Queue interface represents a collection designed for holding elements prior to processing. It follows the FIFO (First-In-First-Out) principle.
It is commonly used in scenarios where elements need to be processed in the order they were added.

Methods in queue interface:

Methods	Description
boolean add(E e)	Inserts the specified element into the queue. Returns true if the element was added successfully. Throws an IllegalStateException if the element cannot be added (due to capacity restrictions).
boolean offer(E e)	Inserts the specified element into the queue. Returns true if the element was added successfully, false otherwise. This method is preferable to add for capacity-restricted queues.
E remove()	Retrieves and removes the head of the queue. Throws a NoSuchElementException if the queue is empty.
E poll()	Retrieves and removes the head of the queue, or returns null if the queue is empty.
E element()	Retrieves, but does not remove, the head of the queue. Throws a NoSuchElementException if the queue is empty.
E peek()	Retrieves, but does not remove, the head of the queue, or returns null if the queue is empty.

Code Example

​x
 
import java.util.Queue;import java.util.ArrayDeque;​public class QueueExample {    public static void main(String[] args) {        // Create a Queue using ArrayDeque        Queue<String> queue = new ArrayDeque<>();​        // Add elements to the queue        queue.add("A");        queue.add("B");        queue.add("C");​        // Display the queue        System.out.println("Queue: " + queue); // Output: Queue: [A, B, C]​        // Retrieve and remove the head of the queue        System.out.println("Removed from queue: " + queue.remove()); // Output: Removed from queue: A        System.out.println("Queue after removal: " + queue); // Output: Queue after removal: [B, C]​        // Retrieve the head of the queue without removing        System.out.println("Head of queue: " + queue.element()); // Output: Head of queue: B​        // Poll the queue (retrieve and remove head or return null if empty)        System.out.println("Polled from queue: " + queue.poll()); // Output: Polled from queue: B        System.out.println("Queue after polling: " + queue); // Output: Queue after polling: [C]​        // Peek at the head of the queue without removing        System.out.println("Peek at head: " + queue.peek()); // Output: Peek at head: C    }}

Deque Interface

Deque:
The Deque interface (Double-Ended Queue) extends the Queue interface and allows elements to be added or removed from both ends of the queue.
It is useful in scenarios where elements need to be processed from both ends, such as implementing a stack or a queue.

Methods:

Operation	Methods
Adding Elements	void addFirst(E e) Inserts the specified element at the front of the deque. Throws a NullPointerException if the specified element is null. void addLast(E e) Inserts the specified element at the end of the deque. Throws a NullPointerException if the specified element is null. boolean offerFirst(E e) Inserts the specified element at the front of the deque. Returns true if the element was added successfully, false otherwise. boolean offerLast(E e) Inserts the specified element at the end of the deque. Returns true if the element was added successfully, false otherwise.
Removing Elements	E removeFirst() Retrieves and removes the first element of the deque. Throws a NoSuchElementException if the deque is empty. E removeLast() Retrieves and removes the last element of the deque. Throws a NoSuchElementException if the deque is empty. E pollFirst() Retrieves and removes the first element of the deque, or returns null if the deque is empty. E pollLast() Retrieves and removes the last element of the deque, or returns null if the deque is empty.
Retrieving Elements	E getFirst() Retrieves, but does not remove, the first element of the deque. Throws a NoSuchElementException if the deque is empty. E getLast() Retrieves, but does not remove, the last element of the deque. Throws a NoSuchElementException if the deque is empty. E peekFirst() Retrieves, but does not remove, the first element of the deque, or returns null if the deque is empty. E peekLast() Retrieves, but does not remove, the last element of the deque, or returns null if the deque is empty.
Stack Operations	void push(E e) Pushes an element onto the stack represented by the deque (equivalent to addFirst). Throws a NullPointerException if the specified element is null. E pop() Pops an element from the stack represented by the deque (equivalent to removeFirst). Throws a NoSuchElementException if the deque is empty.

Code Example

xxxxxxxxxx
 
import java.util.Deque;import java.util.ArrayDeque;​public class DequeExample {    public static void main(String[] args) {        // Create a Deque using ArrayDeque        Deque<String> deque = new ArrayDeque<>();​        // Add elements to the deque at both ends        deque.addFirst("A");        deque.addLast("B");        deque.addFirst("C");        deque.addLast("D");​        // Display the deque        System.out.println("Deque: " + deque); // Output: Deque: [C, A, B, D]​        // Retrieve and remove elements from both ends        System.out.println("Removed first from deque: " + deque.removeFirst()); // Output: Removed          first from deque: C        System.out.println("Removed last from deque: " + deque.removeLast()); // Output: Removed            last from deque: D        System.out.println("Deque after removals: " + deque);         // Output: Deque after removals: [A,    B]​        // Peek at the first and last elements without removing them        System.out.println("Peek first: " + deque.peekFirst()); // Output: Peek first: A        System.out.println("Peek last: " + deque.peekLast()); // Output: Peek last: B​        // Poll the deque (retrieve and remove first or return null if empty)        System.out.println("Polled first: " + deque.pollFirst()); // Output: Polled first: A        System.out.println("Polled last: " + deque.pollLast()); // Output: Polled last: B        System.out.println("Deque after polling: " + deque); // Output: Deque after polling: []    }}

Comparison of Queue and Deque methods

Queue Method		Equivalent Deque Method
-------------		-----------------------
add(e)				addLast(e)
offer(e)			offerLast(e)
remove()			removeFirst()
poll()				pollFirst()
element()			getFirst()
peek()				peekFirst()

ArrayDeque class

ArrayDeque:

ArrayDeque is a resizable-array implementation of the Deque interface. It is not thread-safe but provides fast and efficient implementations of the methods defined by the Deque interface.
Underlying Data Structure: Resizable array.
Inherits all methods from Deque and Queue.

Constructors:

ArrayDeque(): Constructs an empty deque.
ArrayDeque(Collection c): Constructs a deque containing the elements of the specified collection.
ArrayDeque(int intialCapacity): Constructs an empty deque with an initial capacity sufficient to hold the specified number of elements.

Key Points:

Resizable Array: ArrayDeque dynamically resizes its array to accommodate more elements.
No Capacity Restrictions: It does not have capacity restrictions, and it can grow as needed.
Fast Operations: ArrayDeque provides constant time for add, remove, and peek operations at both ends.
Not Thread-Safe: It is not synchronized, so it is not safe for concurrent access by multiple threads.
Preferred for Stack and Queue Operations: It is often used as a stack or a queue due to its efficiency.

Code Example

xxxxxxxxxx
 
import java.util.ArrayDeque;import java.util.Deque;import java.util.Queue;​public class DequeExample {    public static void main(String[] args) {        // Using ArrayDeque as a Queue        Queue<String> queue = new ArrayDeque<>();​        // Add elements to the queue        queue.add("A");        queue.add("B");        queue.add("C");​        // Display the queue        System.out.println("Queue: " + queue); // Output: Queue: [A, B, C]​        // Retrieve and remove the head of the queue        System.out.println("Removed from queue: " + queue.remove()); // Output: Removed from queue: A        System.out.println("Queue after removal: " + queue); // Output: Queue after removal: [B, C]​        // Retrieve the head of the queue without removing        System.out.println("Head of queue: " + queue.element()); // Output: Head of queue: B​        // Using ArrayDeque as a Deque        Deque<String> deque = new ArrayDeque<>();​        // Add elements to the deque at both ends        deque.addFirst("A");        deque.addLast("B");        deque.addFirst("C");        deque.addLast("D");​        // Display the deque        System.out.println("Deque: " + deque); // Output: Deque: [C, A, B, D]​        // Retrieve and remove elements from both ends        System.out.println("Removed first from deque: " + deque.removeFirst()); // Output: Removed          first from deque: C        System.out.println("Removed last from deque: " + deque.removeLast()); // Output: Removed            last from deque: D        System.out.println("Deque after removals: " + deque);         // Output: Deque after removals: [A, B]​        // Using ArrayDeque as a Stack        ArrayDeque<String> stack = new ArrayDeque<>();​        // Push elements onto the stack        stack.push("A");        stack.push("B");        stack.push("C");​        // Display the stack        System.out.println("Stack: " + stack); // Output: Stack: [C, B, A]​        // Pop elements from the stack        System.out.println("Popped from stack: " + stack.pop()); // Output: Popped from stack: C        System.out.println("Stack after pop: " + stack); // Output: Stack after pop: [B, A]​        // Peek at the top element of the stack        System.out.println("Top of stack: " + stack.peek()); // Output: Top of stack: B    }}​

Queue interface, Deque interface, ArrayDeque class & PriorityQueue class

Queue interface

Methods in queue interface:

Deque Interface

Deque:

Methods:

ArrayDeque class

ArrayDeque:

Java Tutorial

Python Tutorial