AbstractQueue in Java with Examples
Last Updated : 26 Nov, 2024
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:
- Abstract Class: It is an abstract class, meaning it cannot be instantiated directly. It serves as a base class for concrete queue implementations.
- 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. - Non-Blocking: Unlike BlockingQueue, it does not provide methods to block threads, instead it focuses on basic queue behavior.
Example:
Java // 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); } } OutputAbstractQueue : [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 // 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); } } OutputAbstractQueue 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 // 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); } } OutputAbstractQueue 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 // 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); } } OutputAbstractQueue1 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 // 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()); } } OutputAbstractQueue1 contains : [10, 20, 30, 40, 50] head : 10
Methods of AbstractQueue
METHOD | DESCRIPTION |
|---|
| add(E e) | Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success, and throwing an IllegalStateException if no space is currently available. |
| addAll(Collection<? extends E> c) | Adds all the elements in the specified collection to this queue. |
| clear() | Removes all the elements from this queue. |
| element() | Retrieves, but does not remove, the head of this queue. |
| remove() | Retrieves and removes the head of this queue. |
Methods declared in class java.util.AbstractCollection
METHOD | DESCRIPTION |
|---|
| contains(Object o) | Returns true if this collection contains the specified element. |
| containsAll(Collection<?> c) | Returns true if this collection contains all of the elements in the specified collection. |
| isEmpty() | Returns true if this collection contains no elements. |
| iterator() | Returns an iterator over the elements contained in this collection. |
| remove(Object o) | Removes a single instance of the specified element from this collection, if it is present (optional operation). |
| removeAll(Collection<?> c) | Removes all of this collection’s elements that are also contained in the specified collection (optional operation). |
| retainAll(Collection<?> c) | Retains only the elements in this collection that are contained in the specified collection (optional operation). |
| toArray() | Returns an array containing all of the elements in this collection. |
| toArray(T[] a) | Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array. |
| toString() | Returns a string representation of this collection. |
Methods declared in interface java.util.Collection
METHOD | DESCRIPTION |
|---|
| contains(Object o) | Returns true if this collection contains the specified element. |
| containsAll(Collection<?> c) | Returns true if this collection contains all the elements in the specified collection. |
| equals(Object o) | Compares the specified object with this collection for equality. |
| hashCode() | Returns the hash code value for this collection. |
| isEmpty() | Returns true if this collection contains no elements. |
| iterator() | Returns an iterator over the elements in this collection. |
| parallelStream() | Returns a possibly parallel Stream with this collection as its source. |
| remove(Object o) | Removes a single instance of the specified element from this collection, if it is present (optional operation). |
| removeAll(Collection<?> c) | Removes all of this collection’s elements that are also contained in the specified collection (optional operation). |
| removeIf(Predicate<? super E> filter) | Removes all the elements of this collection that satisfy the given predicate. |
| retainAll(Collection<?> c) | Retains only the elements in this collection that are contained in the specified collection (optional operation). |
| size() | Returns the number of elements in this collection. |
| spliterator() | Creates a Spliterator over the elements in this collection. |
| stream() | Returns a sequential Stream with this collection as its source. |
| toArray() | Returns an array containing all the elements in this collection. |
| toArray(IntFunction<T[]> generator) | Returns an array containing all the elements in this collection, using the provided generator function to allocate the returned array. |
| toArray(T[] a) | Returns an array containing all the elements in this collection; the runtime type of the returned array is that of the specified array. |
Methods declared in interface java.lang.Iterable
METHOD | DESCRIPTION |
|---|
| forEach(Consumer<? super T> action) | Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception. |
Methods declared in interface java.util.Queue
METHOD | DESCRIPTION |
|---|
| offer(E e) | Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions. |
| peek() | Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty. |
| poll() | Retrieves and removes the head of this queue, or returns null if this queue is empty. |
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
Java 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); } } OutputQueue: [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)