In Java, the Deque interface is a double-ended queue that provides functionality for manipulating both queues and stacks. It supports adding, removing, and inspecting elements from both ends of the queue, allowing us to implement various queue and stack data structures.

Here, we’ll explore how to use the Deque interface to implement queues and stacks in Java.

Queue Implementation

To implement a queue using the Deque interface, we can utilize the add() method to add elements at the end of the queue, and the remove() method to remove elements from the front of the queue.

import java.util.Deque;
import java.util.LinkedList;

public class QueueExample {
    public static void main(String[] args) {
        Deque<String> queue = new LinkedList<>();

        // Adding elements to the queue
        queue.add("Apple");
        queue.add("Banana");
        queue.add("Cherry");

        // Removing elements from the queue
        String firstElement = queue.remove();
        System.out.println("Removed element: " + firstElement);

        // Peek the first element without removing
        String peekElement = queue.peek();
        System.out.println("Peeked element: " + peekElement);
    }
}

In the above example, we first import the required classes. Then, we create an instance of the Deque interface using the LinkedList class, which provides a doubly-linked list implementation of the Deque interface.

We add elements to the queue using the add() method, and remove elements from the front of the queue using the remove() method. The peek() method allows us to inspect the first element without removing it.

Stack Implementation

To implement a stack using the Deque interface, we can also use the add() method to add elements at the beginning of the stack, and the remove() method to remove elements from the beginning of the stack.

import java.util.Deque;
import java.util.LinkedList;

public class StackExample {
    public static void main(String[] args) {
        Deque<String> stack = new LinkedList<>();

        // Pushing elements to the stack
        stack.addFirst("Apple");
        stack.addFirst("Banana");
        stack.addFirst("Cherry");

        // Popping elements from the stack
        String firstElement = stack.removeFirst();
        System.out.println("Popped element: " + firstElement);

        // Peek the top element without popping
        String peekElement = stack.peekFirst();
        System.out.println("Peeked element: " + peekElement);
    }
}

Similar to the queue implementation, we create an instance of the Deque interface using the LinkedList class. Instead of adding elements using the add() method, we use addFirst() to add elements at the beginning of the stack. The removeFirst() method is used to remove elements from the top of the stack, and peekFirst() allows us to peek at the top element without removing it.

By utilizing the Deque interface, we can implement both queues and stacks in Java. Whether you need a data structure that follows the FIFO (First-In, First-Out) principle like queues or follows the LIFO (Last-In, First-Out) principle like stacks, the Deque interface provides the necessary operations to manipulate the data efficiently.

#java #queues #stacks