Add Queue and Deque data structure

Author: Thisal-D

README.md

@@ -40,9 +40,11 @@ A repository for understanding Java data structures. Covers primitive data types
 │&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── [**`Hash Map`**](./non-primitive-data-types/collections/Map/Hash-Map/) [<sub>HashMapDataStructure.java</sub>](./non-primitive-data-types/collections/Map/Hash-Map/HashMapDataStructure.java)<br>
 │&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── [**`Linked Hash Map`**](./non-primitive-data-types/collections/Map/Linked-Hash-Map/) [<sub>LinkedHashMapDataStructure.java</sub>](./non-primitive-data-types/collections/Map/Linked-Hash-Map/LinkedHashMapDataStructure.java)<br>
 │&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── [**`Tree Map`**](./non-primitive-data-types/collections/Map/Tree-Map/) [<sub>TreeMapDataStructure.java</sub>](./non-primitive-data-types/collections/Map/Tree-Map/TreeMapDataStructure.java)<br>
-│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── [**`Hash table`**](./non-primitive-data-types/collections/Map/Hash-table/) [<sub>HashtableDataStructure.java</sub>](./non-primitive-data-types/collections/Map/Hash-table/HashtableDataStructure.java)<br>
-│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── [**`Queue`**](./non-primitive-data-types/collections/Queue/) [<sub>QueueInterface.java</sub>](./non-primitive-data-types/collections/Queue/QueueExample.java)<br>
-│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;└── [**`Deque`**](./non-primitive-data-types/collections/Deque/) [<sub>DequeInterface.java</sub>](./non-primitive-data-types/collections/Deque/DequeExample.java)<br>│<br>
+│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;└── [**`Hash table`**](./non-primitive-data-types/collections/Map/Hash-table/) [<sub>HashtableDataStructure.java</sub>](./non-primitive-data-types/collections/Map/Hash-table/HashtableDataStructure.java)<br>
+│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── [**`Queue`**](./non-primitive-data-types/collections/Queue/) [<sub>QueueInterface.java</sub>](./non-primitive-data-types/collections/Queue/QueueInterface.java)<br>
+│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;└── [**`Priority Queue`**](./non-primitive-data-types/collections/Queue/Priority-Queue/) [<sub>PriorityQueueDataStructure.java</sub>](./non-primitive-data-types/collections/Queue/Priority-Queue/PriorityQueueDataStructure.java)<br>
+│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;└── [**`Deque`**](./non-primitive-data-types/collections/Deque/) [<sub>DequeInterface.java</sub>](./non-primitive-data-types/collections/Deque/DequeInterface.java)<br>│<br>
+│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;│&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;└── [**`Array Deque`**](./non-primitive-data-types/collections/Deque/Array-Deque/) [<sub>ArrayDequeDataStructure.java</sub>](./non-primitive-data-types/collections/Deque/Array-Deque/ArrayDequeDataStructure.java)<br>
 │<br>
 ├── README.md<br>
 │<br>

non-primitive-data-types/collections/Deque/Array-Deque/ArrayDequeDataStructure.java

@@ -0,0 +1,109 @@
+import java.util.*;
+
+public class ArrayDequeDataStructure {
+    public static void main(String[] args) {
+        // Create an ArrayDeque
+        ArrayDeque<String> arrayDeque = new ArrayDeque<>();
+
+        // Add elements
+        arrayDeque.offer("Apple");
+        arrayDeque.offer("Banana");
+        arrayDeque.offer("Cherry");
+        arrayDeque.offer("Date");
+        arrayDeque.offer("Elderberry");
+
+        // Demonstrate basic operations
+        demonstrateBasicOperations(arrayDeque);
+
+        // Demonstrate advanced operations
+        demonstrateAdvancedOperations(arrayDeque);
+
+        // Demonstrate ArrayDeque specific methods
+        demonstrateArrayDequeSpecificMethods(arrayDeque);
+    }
+
+    public static void demonstrateBasicOperations(ArrayDeque<String> arrayDeque) {
+        System.out.println("Basic ArrayDeque Operations:");
+
+        // Check size
+        System.out.println("Size of the ArrayDeque: " + arrayDeque.size());
+
+        // Access and remove elements (ArrayDeque does not allow direct access by index)
+        System.out.println("Poll the first element: " + arrayDeque.pollFirst());
+        System.out.println("Poll the last element: " + arrayDeque.pollLast());
+
+        // Check if an element exists
+        System.out.println("Contains 'Banana': " + arrayDeque.contains("Banana"));
+
+        // Iterate over elements
+        System.out.println("ArrayDeque elements:");
+        for (String fruit : arrayDeque) {
+            System.out.println(fruit);
+        }
+
+        // Clear the ArrayDeque
+        arrayDeque.clear();
+        System.out.println("Is ArrayDeque empty? " + arrayDeque.isEmpty());
+        System.out.println(); // Empty line for better readability
+    }
+
+    public static void demonstrateAdvancedOperations(ArrayDeque<String> arrayDeque) {
+        System.out.println("Advanced ArrayDeque Operations:");
+
+        // Add elements again for demonstration
+        arrayDeque.offer("Apple");
+        arrayDeque.offer("Banana");
+        arrayDeque.offer("Cherry");
+        arrayDeque.offer("Date");
+        arrayDeque.offer("Elderberry");
+
+        // Peek the first and last elements
+        System.out.println("First element: " + arrayDeque.peekFirst());
+        System.out.println("Last element: " + arrayDeque.peekLast());
+
+        // Remove specific element
+        arrayDeque.remove("Banana");
+        System.out.println("ArrayDeque after removing 'Banana': " + arrayDeque);
+
+        // Convert ArrayDeque to array
+        Object[] array = arrayDeque.toArray();
+        System.out.println("Array from ArrayDeque: " + Arrays.toString(array));
+
+        // Reverse the ArrayDeque (not directly supported, but can be done manually)
+        List<String> list = new ArrayList<>(arrayDeque);
+        Collections.reverse(list);
+        System.out.println("Reversed ArrayDeque (using List): " + list);
+
+        System.out.println(); // Empty line for better readability
+    }
+
+    public static void demonstrateArrayDequeSpecificMethods(ArrayDeque<String> arrayDeque) {
+        System.out.println("ArrayDeque Specific Methods:");
+
+        // Add elements again for demonstration
+        arrayDeque.offer("Fig");
+
+        // Use the addFirst() and addLast() methods
+        arrayDeque.addFirst("Grapes");
+        arrayDeque.addLast("Honeydew");
+
+        System.out.println("ArrayDeque after addFirst() and addLast(): " + arrayDeque);
+
+        // Use the offerFirst() and offerLast() methods
+        arrayDeque.offerFirst("Indian Fig");
+        arrayDeque.offerLast("Jackfruit");
+
+        System.out.println("ArrayDeque after offerFirst() and offerLast(): " + arrayDeque);
+
+        // Peek the first and last elements using peekFirst() and peekLast()
+        System.out.println("First element using peekFirst(): " + arrayDeque.peekFirst());
+        System.out.println("Last element using peekLast(): " + arrayDeque.peekLast());
+
+        // Remove the first and last elements using removeFirst() and removeLast()
+        System.out.println("Removed first element using removeFirst(): " + arrayDeque.removeFirst());
+        System.out.println("Removed last element using removeLast(): " + arrayDeque.removeLast());
+
+        System.out.println("ArrayDeque after removing first and last elements: " + arrayDeque);
+        System.out.println(); // Empty line for better readability
+    }
+}

non-primitive-data-types/collections/Deque/Array-Deque/README.md

@@ -0,0 +1,101 @@
+# `ArrayDeque` in Java
+
+## Overview
+
+The `ArrayDeque` class in Java is a part of the `java.util` package and implements the `Deque` interface. It provides a resizable array-based implementation of a double-ended queue, allowing elements to be added or removed from both ends efficiently.
+
+---
+
+## Characteristics of `ArrayDeque`
+
+| **Feature**              | **Details**                                   |
+|--------------------------|-----------------------------------------------|
+| **Package**              | `java.util`                                  |
+| **Allows Duplicates**    | Yes                                          |
+| **Ordering**             | FIFO (First In, First Out) or LIFO (Last In, First Out) depending on usage |
+| **Thread-Safe**          | No                                           |
+| **Initial Capacity**     | 16 (default)                                 |
+
+---
+
+## Key Features of `ArrayDeque`
+
+- **Double-Ended Queue**: Allows insertion and removal of elements from both ends of the queue.
+- **Efficient Operations**: All operations (add, remove) are done in constant time (`O(1)`).
+- **Resizable Array**: The underlying array dynamically grows or shrinks as needed.
+- **Not Synchronized**: Unlike `LinkedList`, `ArrayDeque` is not thread-safe.
+- **No Capacity Limitation**: The deque grows as needed, with no fixed size.
+
+---
+
+## How to Use `ArrayDeque`
+
+### Importing `ArrayDeque`
+
+```java
+import java.util.ArrayDeque;
+```
+
+### Creating an `ArrayDeque`
+
+```java
+ArrayDeque<Type> arrayDeque = new ArrayDeque<>();
+```
+
+- Example
+    
+    ```java
+    ArrayDeque<Integer> integerDeque = new ArrayDeque<>();
+    ArrayDeque<String> stringDeque = new ArrayDeque<>();
+    ```
+
+---
+
+## `ArrayDeque` Specific Methods
+The `ArrayDeque` class provides additional methods beyond those in the `Queue` and `Deque` interfaces. Here are some commonly used ones:
+
+| Method            | Description                                                                                  | Return Type | Example                                        |
+|-------------------|----------------------------------------------------------------------------------------------|-------------|------------------------------------------------|
+| addFirst()        | Inserts the specified element at the front of the deque.                                     | void        | `arrayDeque.addFirst(10);`                      |
+| addLast()         | Inserts the specified element at the end of the deque.                                       | void        | `arrayDeque.addLast(20);`                       |
+| offerFirst()      | Inserts the specified element at the front of the deque, returning true if successful.       | boolean     | `boolean added = arrayDeque.offerFirst(30);`    |
+| offerLast()       | Inserts the specified element at the end of the deque, returning true if successful.        | boolean     | `boolean added = arrayDeque.offerLast(40);`     |
+| peekFirst()       | Retrieves, but does not remove, the first element of the deque, or returns null if empty.    | Type        | `Type first = arrayDeque.peekFirst();`          |
+| peekLast()        | Retrieves, but does not remove, the last element of the deque, or returns null if empty.     | Type        | `Type last = arrayDeque.peekLast();`            |
+| pollFirst()       | Retrieves and removes the first element of the deque, or returns null if empty.             | Type        | `Type first = arrayDeque.pollFirst();`          |
+| pollLast()        | Retrieves and removes the last element of the deque, or returns null if empty.              | Type        | `Type last = arrayDeque.pollLast();`            |
+| removeFirst()     | Removes and returns the first element of the deque.                                          | Type        | `Type first = arrayDeque.removeFirst();`        |
+| removeLast()      | Removes and returns the last element of the deque.                                           | Type        | `Type last = arrayDeque.removeLast();`          |
+
+---
+
+## Example Code
+
+```java
+import java.util.ArrayDeque;
+
+public class ArrayDequeExample {
+    public static void main(String[] args) {
+        // Create an ArrayDeque
+        ArrayDeque<Integer> arrayDeque = new ArrayDeque<>();
+
+        // Add elements
+        arrayDeque.addFirst(10);
+        arrayDeque.addLast(20);
+        arrayDeque.addFirst(30);
+
+        // Peek at the first and last elements
+        System.out.println("First element: " + arrayDeque.peekFirst());
+        System.out.println("Last element: " + arrayDeque.peekLast());
+
+        // Remove elements
+        System.out.println("Removed first element: " + arrayDeque.pollFirst());
+        System.out.println("Removed last element: " + arrayDeque.pollLast());
+
+        // Display the remaining elements
+        System.out.println("Remaining elements: " + arrayDeque);
+    }
+}
+```
+
+> **For more:** [`ArrayDequeDataStructure.java`](./ArrayDequeDataStructure.java)

non-primitive-data-types/collections/Deque/DequeInterface.java

@@ -0,0 +1,123 @@
+import java.util.*;
+
+public class DequeInterface {
+    public static void main(String[] args) {
+        // Create a deque
+        Deque<String> deque = new LinkedList<>();
+
+        // Demonstrate basic operations
+        demonstrateBasicOperations(deque);
+
+        // Demonstrate advanced operations
+        demonstrateAdvancedOperations(deque);
+
+        // Demonstrate additional operations
+        demonstrateAllMethods(deque);
+    }
+
+    private static void demonstrateBasicOperations(Deque<String> deque) {
+        System.out.println("Basic Deque Operations:");
+
+        // Add elements at the end
+        deque.offerLast("Apple");
+        deque.offerLast("Banana");
+        deque.offerLast("Cherry");
+
+        // Peek at the front element
+        System.out.println("Front element (peekFirst): " + deque.peekFirst());
+
+        // Peek at the last element
+        System.out.println("Last element (peekLast): " + deque.peekLast());
+
+        // Check size
+        System.out.println("Size of the deque: " + deque.size());
+
+        // Remove an element from the front
+        System.out.println("Removed element (pollFirst): " + deque.pollFirst());
+
+        // Remove an element from the end
+        System.out.println("Removed element (pollLast): " + deque.pollLast());
+
+        // Check if an element exists
+        System.out.println("Contains 'Banana': " + deque.contains("Banana"));
+
+        // Iterate over elements
+        System.out.println("Deque elements:");
+        for (String fruit : deque) {
+            System.out.println(fruit);
+        }
+
+        // Clear the deque
+        deque.clear();
+        System.out.println("Is deque empty? " + deque.isEmpty());
+        System.out.println(); // Empty line for better readability
+    }
+
+    private static void demonstrateAdvancedOperations(Deque<String> deque) {
+        System.out.println("Advanced Deque Operations:");
+
+        // Add elements again for demonstration
+        deque.offerLast("Apple");
+        deque.offerLast("Banana");
+        deque.offerLast("Cherry");
+        deque.offerLast("Date");
+
+        // Using forEach to iterate
+        System.out.println("Deque elements (using forEach):");
+        deque.forEach(System.out::println);
+
+        // Using an iterator
+        System.out.println("Deque elements (using iterator):");
+        Iterator<String> iterator = deque.iterator();
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+        }
+
+        // Using descending iterator
+        System.out.println("Deque elements (using descending iterator):");
+        Iterator<String> descendingIterator = deque.descendingIterator();
+        while (descendingIterator.hasNext()) {
+            System.out.println(descendingIterator.next());
+        }
+
+        // Access head and tail without removal
+        System.out.println("Head element (getFirst): " + deque.getFirst());
+        System.out.println("Tail element (getLast): " + deque.getLast());
+
+        // Remove elements using removeFirst and removeLast
+        try {
+            while (!deque.isEmpty()) {
+                System.out.println("Removed from front (removeFirst): " + deque.removeFirst());
+                if (!deque.isEmpty()) {
+                    System.out.println("Removed from end (removeLast): " + deque.removeLast());
+                }
+            }
+        } catch (NoSuchElementException e) {
+            System.out.println("Deque is empty!");
+        }
+
+        System.out.println("Is deque empty after removing all elements? " + deque.isEmpty());
+        System.out.println(); // Empty line for better readability
+    }
+
+    private static void demonstrateAllMethods(Deque<String> deque) {
+        System.out.println("Demonstrating All Methods:");
+
+        // Add elements at both ends
+        deque.addFirst("Mango");
+        deque.addLast("Pineapple");
+
+        // Convert to array
+        Object[] array = deque.toArray();
+        System.out.println("Deque as array: " + Arrays.toString(array));
+
+        // Remove specific elements
+        deque.remove("Mango");
+        System.out.println("After removing 'Mango': " + deque);
+
+        // Clear and check isEmpty
+        deque.clear();
+        System.out.println("Cleared deque. Is empty? " + deque.isEmpty());
+        System.out.println(); // Empty line for better readability
+    }
+}