Java Queue

The Java.util package has the interface Queue, which does extend the Collection interface. It is used to protect the parts that are managed using the FIFO approach.

Being an interface, the queue needs a concrete class for the declaration, and the most popular classes in Java are the LinkedList and Priority Queue. It is an ordered list of objects where new elements are added at the end and old elements are deleted at the beginning. The implementations of these classes are not thread safe. If a thread-safe implementation is required, PriorityBlockingQueue is an option.

Queue Interface Statement:

It is stated that the Queue interface is:

public interface Queue<Q> extends Collection<Q> 

Creating queue objects:

The queue is an interface; hence it is not possible to create objects of the type of queue. To build an object, we always need a class that extends this list. Additionally, because Java 1.5 included Generics, it is now able to limit the kinds of objects that can be stored in the Queue.

This type-safe queue is described as follows:

Queue<O> queue = new PriorityQueue<O> (); 

Methods of Java Queue Interface:

Queue Characteristics

• The queue is utilized to add elements to the end of the queue and delete items from the queue's beginning. It uses the FIFO principle.
• All Collection interface methods, such as insertion, deletion, etc., are supported by the Java Queue.
• The most popular implementations are PriorityQueue, ArrayBlockingQueue, and LinkedList.
• If a null action is performed on a blocking queue, a NullPointerException is raised.
• Unbounded Queues are the Queues included in java.util package.
• The Bounded Queues are the Queues that are included in the java.util.concurrent package.
• All other queues do not allow insertion or removal, but the Deque does at the tail and head of the queue, respectively. The Deques permit the addition and elimination of components from either end.

Example:

QueueExpl1.java

import java.util.*;
 class QueueExpl1 {
  
    public static void main(String args[])
    {
        Queue<String> q = new PriorityQueue<>();
  
        q.add("Welcome");
        q.add("To");
        q.add("JavaTpoint");
        System.out.print(q);
        q.remove("Welcome");
        System.out.print(q);
    }
}

Output:

The following classes support the Queue Interface:

Priority Queue class:

Another class defined in the collection framework, PriorityQueue, provides a method for prioritizing objects as they are processed. In the Java queue, object insertion and deletion are described as following a FIFO pattern. However, a PriorityQueue can be used when it is necessary to process queue elements in accordance with their priority.

PriorityQueue Class Declaration:

Let's examine the java.util.PriorityQueue class declaration.

public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable

Let us understand more about this using an example.

Priority Queue Example

PriorityQueueExpl.java

import java.util.*;  
class PriorityQueueExpl{  
public static void main(String args[]){  
PriorityQueue<String> q = new PriorityQueue<String>();  
q.add("Welcome");  
q.add("to");  
q.add("Java");  
q.add("T");  
q.add("point");  
System.out.println(" "+q.element());  
System.out.println(" "+q.peek());  
System.out.println(" repeating the queue's components ");  
Iterator i = q.iterator();  
while(i.hasNext()){  
System.out.println(i.next());  
}  
q.remove();  
q.poll();  
System.out.println("after eliminating two components:");  
Iterator<String> i2=q.iterator();  
while(i2.hasNext()){  
System.out.println(i2.next());  
}  
}  
}  

Output:

LinkedList:

The collection framework's built-in class LinkedList implements the linked list data structure by default. Each element is a discrete object with a data piece and an address section, and the components are not retained in sequential locations. It is a linear data structure. The elements are linked together via pointers and addresses. Every component is known as a node. Because of their dynamic nature and ease of insertions and removals, they are preferred to queues or arrays. Let's examine how to create a queue object using this class.

Let us understand more about this using an example.

LinkedListExpl.java

import java.util.*;
class LinkedListExpl
 {
 public static void main(String args[])
    {
        // Empty LinkedList is created
        Queue<Integer> ll1 = new LinkedList<Integer>()
// Adding elements to the ll1
        ll1.add(1);
        ll1.add(2);
        ll1.add(5);
 // Topmost element is printed
        System.out.println(ll1.peek());
        System.out.println(ll1.poll());
       // Topmost element is printed
        System.out.println(ll1.peek());
    }
}

Output:

Priority Blocking Queue:

It should be emphasized that neither the PriorityQueue nor the LinkedList implementations are thread safe. If a thread-safe solution is required, one possibility is PriorityBlockingQueue. An unbounded blocking queue that offers to block retrieval operations and adheres to the same ordering rules as the PriorityQueue class is the PriorityBlockingQueue.

Due to resource exhaustion brought on by adding elements occasionally failing with an OutOfMemoryError due to its unbounded nature.

Let us understand with an example.

PBQExpl.java

import java.util.concurrent.PriorityBlockingQueue;
import java.util.*;
class PBQExpl {
    public static void main(String args[])
    {
        // Empty Priority Blocking Queue is created
        Queue<Integer> pbq1 = new PriorityBlockingQueue<Integer>();
   // Adding items to the pbq1
        pbq1.add(1);
        pbq1.add(2);
        pbq1.add(5);
  
        // Top most element is printed
        System.out.println(pbq1.peek());
  
        // Top most element is printed and
        // it is removed from Priority Block Queue
        System.out.println(pbq1.poll());
  
        // Top most element is printed
        System.out.println(pbq1.peek());
    }
}

Output: