AbstractQueue in Java with Examples

The AbstractQueue class in Java is a part of the Java Collection Framework and implements the Collection interface and the AbstractCollection class. It provides skeletal implementations of some Queue operations. The implementations in this class are appropriate when the base implementation does not allow null elements.

Methods add, remove, and element are based on offer, poll, and peek, respectively, but throw exceptions instead of indicating failure via false or null returns. 

Key Features of AbstractQueue:

1. Abstract Class: It is an abstract class, meaning it cannot be instantiated directly. It serves as a base class for concrete queue implementations.
2. Partial Implementation: Provides default implementations for common methods of the Queue interface, such as add(), remove(), and element(). These methods internally call the abstract methods offer(), poll(), and peek(), which must be implemented by subclasses.
3. Non-Blocking: Unlike BlockingQueue, it does not provide methods to block threads, instead it focuses on basic queue behavior.

Example:

// Java Program Implementing AbstractQueue
import java.util.*; 
import java.util.concurrent.LinkedBlockingQueue; 

public class Main
{ 
    public static void main(String[] args)
    { 
        // Creating object of AbstractQueue<Integer> 
        AbstractQueue<Integer> a = new LinkedBlockingQueue<Integer>();
  
        // Adding element
        a.add(1); 
        a.add(2); 
        a.add(3);
  
        System.out.println("AbstractQueue : " + a); 
    } 
} 

AbstractQueue : [1, 2, 3]

Class Hierarchy: 

java.lang.Object
↳ java.util.AbstractCollection<E>
↳ Class AbstractQueue<E>

This class implements Iterable<E>, Collection<E>, Queue<E> interfaces and extends AbstractCollection

Declaration of AbstractQueue

public abstract class AbstractQueue<E> extends AbstractCollection<E>
implements Queue<E> 

E - Type of element maintained by the Collection Framework class or interface.

Constructors in Java AbstractQueue

Since AbstractQueue is an abstract class, it's implementation is provided by its sub-classes. Below shows the list of classes that can provide the implementation. To create it, we need to it from java.util.AbstractQueue.

protected AbstractQueue(): The default constructor, but being abstract, it doesn't allow to create an AbstractQueue object.

The implementation should be provided by one of its subclasses like ArrayBlockingQueue, ConcurrentLinkedQueue, DelayQueue, LinkedBlockingDeque, LinkedBlockingQueue, LinkedTransferQueue, PriorityBlockingQueue, PriorityQueue, SynchronousQueue.

AbstractQueue<E> objName = new ArrayBlockingQueue<E>();

 Below is a sample program to illustrate AbstractQueue in Java: 

// Java code to illustrate AbstractQueue
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;

public class AbstractQueueExample 
{
    public static void main(String[] argv) throws Exception
    {
        // Creating object of AbstractQueue<Integer>
        AbstractQueue<Integer> a = new LinkedBlockingQueue<Integer>();

        // Adding elements to the Queue
        a.add(10);
       	a.add(20);
        a.add(30);
        a.add(40);
        a.add(50);

        // Print the queue contents to the console
        System.out.println("AbstractQueue contains: " + a);
    }
}

AbstractQueue contains: [10, 20, 30, 40, 50]

Basic Operations

1. Adding Elements

To add elements into the AbstractQueue, it provides two methods. The add(E e) method inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions. It returns true upon success and throws an IllegalStateException if no space is currently available. The addAll(E e) method adds all the elements in the specified collection to this queue.

// Java program to illustrate the
// adding elements to the AbstractQueue

import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;

public class AddingElementsExample {

    public static void main(String[] argv) throws Exception
    {
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ1 = new LinkedBlockingQueue<Integer>();

        // Populating AQ
        AQ1.add(10);
        AQ1.add(20);
        AQ1.add(30);
        AQ1.add(40);
        AQ1.add(50);

        // print AQ
        System.out.println("AbstractQueue contains : "
                           + AQ1);

        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ2 = new LinkedBlockingQueue<Integer>();

        // print AQ2 initially
        System.out.println("AbstractQueue2 initially contains : " + AQ2);

        // adds elements of AQ1 in AQ2
        AQ2.addAll(AQ1);

        System.out.println( "AbstractQueue1 after addition contains : " + AQ2);
    }
}

AbstractQueue contains : [10, 20, 30, 40, 50]
AbstractQueue2 initially contains : []
AbstractQueue1 after addition contains : [10, 20, 30, 40, 50]

2. Remove the Elements 

To remove the elements from AbstractQueue, it provides remove() and clear() methods.

• The remove() method returns and removes the head of this queue.
• The clear() method removes all the elements from this queue. The queue will be empty after this call returns.
   

// Java program to illustrate the
// removal of elements from AbstractQueue

import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;

public class RemovingElementsExample {
    public static void main(String[] argv) throws Exception
    {
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ1 = new LinkedBlockingQueue<Integer>();

        // Add elements using add method
        AQ1.add(10);
        AQ1.add(20);
        AQ1.add(30);
        AQ1.add(40);
        AQ1.add(50);

        // print the queue contents to the console
        System.out.println("AbstractQueue1 contains : " + AQ1);

        // Retrieves the head
        int head = AQ1.remove();

        // print the head element to the console
        System.out.println("head : " + head);

        // print the modified queue
        System.out.println("AbstractQueue1 after removal of head : " + AQ1);

        // remove all the elements
        AQ1.clear();

        // print the modified queue
        System.out.println("AbstractQueue1 : " + AQ1);
    }
}

AbstractQueue1 contains : [10, 20, 30, 40, 50]
head : 10
AbstractQueue1 after removal of head : [20, 30, 40, 50]
AbstractQueue1 : []

3. Accessing the Elements

The element() method of AbstractQueue retrieves but does not remove, the head of this queue.

// Java program to illustrate the
// accessing element from AbstractQueue

import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;

public class AccessingElementExample 
{
    public static void main(String[] argv) throws Exception
    {
        // Since AbstractQueue is an abstract class
        // create object using LinkedBlockingQueue
        AbstractQueue<Integer> AQ1 = new LinkedBlockingQueue<Integer>();

        // Populating AQ1 using add method
        AQ1.add(10);
        AQ1.add(20);
        AQ1.add(30);
        AQ1.add(40);
        AQ1.add(50);

        // print AQ to the console
        System.out.println("AbstractQueue1 contains : " + AQ1);

        // access the head element
        System.out.println("head : " + AQ1.element());
    }
}

AbstractQueue1 contains : [10, 20, 30, 40, 50]
head : 10

Methods of AbstractQueue

Methods declared in class java.util.AbstractCollection

Methods declared in interface java.util.Collection

Methods declared in interface java.lang.Iterable

Methods declared in interface java.util.Queue

Reference: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/AbstractQueue.html

Explanation

In Java, an abstract queue is a data structure that follows the FIFO (First-In-First-Out) principle, meaning that the first element added to the queue is the first one to be removed. The abstract queue is an abstract class that serves as a base class for the various queue implementations in Java.

An abstract queue provides a set of methods that are common to all queue implementations, such as adding an element to the back of the queue, removing an element from the front of the queue, and peeking at the element at the front of the queue without removing it. These methods are defined in the abstract class and can be overridden by the concrete queue implementations.

Some of the common methods provided by the abstract queue class are:

• add(): This method is used to add an element to the back of the queue. If the queue is full, it throws an exception.
• offer(): This method is used to add an element to the back of the queue. If the queue is full, it returns false.
• remove(): This method is used to remove and return the element at the front of the queue. If the queue is empty, it throws an exception.
• poll(): This method is used to remove and return the element at the front of the queue. If the queue is empty, it returns null.
• element(): This method is used to peek at the element at the front of the queue without removing it. If the queue is empty, it throws an exception.
• peek(): This method is used to peek at the element at the front of the queue without removing it. If the queue is empty, it returns null.

Some of the concrete implementations of the abstract queue in Java are:

• LinkedList: The LinkedList class in Java implements the Queue interface and provides a concrete implementation of the abstract queue.
• ArrayDeque: The ArrayDeque class in Java provides a resizable-array implementation of the abstract queue.
• PriorityQueue: The PriorityQueue class in Java provides an unbounded priority queue based on a priority heap.

The abstract queue in Java is useful in a variety of applications where elements need to be processed in the order in which they were added. It is used in situations such as:

• Implementing a message queue in a messaging system.
• Implementing a task queue in a multithreaded application.
• Implementing a buffer for data processing in a streaming system.

Overall, the abstract queue in Java is a versatile and powerful tool for managing collections of data in a first-in-first-out manner.

Program

import java.util.Queue;
import java.util.LinkedList;

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

        // Add elements to the queue
        queue.add("Alice");
        queue.add("Bob");
        queue.add("Charlie");
        queue.add("David");

        // Print the elements in the queue
        System.out.println("Queue: " + queue);

        // Remove the first element from the queue
        String first = queue.remove();
        System.out.println("Removed element: " + first);

        // Print the remaining elements in the queue
        System.out.println("Queue: " + queue);

        // Peek at the first element in the queue
        String peeked = queue.peek();
        System.out.println("Peeked element: " + peeked);

        // Print the remaining elements in the queue
        System.out.println("Queue: " + queue);
    }
}

Queue: [Alice, Bob, Charlie, David]
Removed element: Alice
Queue: [Bob, Charlie, David]
Peeked element: Bob
Queue: [Bob, Charlie, David]

In this example, we create a new queue using the concrete implementation LinkedList. We then add four elements to the queue and print the elements using the System.out.println() statement.

We then remove the first element from the queue using the remove() method and print the removed element. We print the remaining elements in the queue again using the System.out.println() statement.

We then peek at the first element in the queue using the peek() method and print the peeked element. Finally, we print the remaining elements in the queue using the System.out.println() statement.

Time and space complexity

The time and space complexity of an abstract queue in Java depends on the concrete implementation being used. In this example, we used LinkedList to implement the queue.

The time complexity of various operations on LinkedList are as follows:

add(element): O(1)
remove(): O(1)
peek(): O(1)
Therefore, the time complexity of adding an element to the queue, removing an element from the queue, and peeking at the first element in the queue are all O(1).

The space complexity of a queue implemented using LinkedList is O(n), where n is the number of elements in the queue. This is because the LinkedList internally uses a dynamic array to store its elements, which may need to be resized as elements are added or removed. However, the exact space complexity may depend on the implementation details of the LinkedList class.

In summary, the time complexity of adding, removing, and peeking at elements in an abstract queue implemented using LinkedList is O(1), while the space complexity is O(n)