AbstractQueue in Java with Examples - GeeksforGeeks

10 Feb, 2022
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. 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: 
public abstract class AbstractQueue<E> extends AbstractCollection<E> implements Queue<E>  
E – Type of element maintained by the Collection Framework class or interface.
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> AQ = new LinkedBlockingQueue<Integer>();         // Adding elements to the Queue        AQ.add(10);        AQ.add(20);        AQ.add(30);        AQ.add(40);        AQ.add(50);         // print the queue contents to the console        System.out.println("AbstractQueue contains: " + AQ);    }}
AbstractQueue contains: [10, 20, 30, 40, 50]
 
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);    }}
  
 
 
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
// 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
// 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
METHOD
DESCRIPTION
METHOD
DESCRIPTION
METHOD
DESCRIPTION
METHOD
DESCRIPTION
METHOD
DESCRIPTION
Reference: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/AbstractQueue.html
 
Ganeshchowdharysadanala
sagar0719kumar
Java - util package
java-AbstractQueue
Java-Collections
Java
Java
Java-Collections
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Object Oriented Programming (OOPs) Concept in Java
HashMap in Java with Examples
How to iterate any Map in Java
Interfaces in Java
Initialize an ArrayList in Java
ArrayList in Java
Multidimensional Arrays in Java
Singleton Class in Java
LinkedList in Java
Collections in Java