Queue in Java

The queue data structure uses the First In First Out (FIFO) principle. It is used to hold the object to be processed in order of their arrival; this is very similar to the line of people standing in a queue. As Java provides large support for data structure in the form of the Collection interface, the queue is an interface available in the Collection interface. It extends the Collection interface. It is available in Java.util package and supports all the operations available in the Collection interface, along with some additional extraction, insertion, and inspection operations.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Syntax:

Interface Queue<E>

The queue is an interface, not a class, so it cannot be instantiated directly. The declaration shows that the queue accepts values as generic similar to collections, and we can pass any object to it. Java has multiple implementations of the Queue interface, which we can use while using the Queues. They are LinkedList and PriorityQueue.

A queue can be declared as below:

Queue< Object > q = new LinkedList<>();

Queue< Object > q = new PriorityQueue<>();

How does queue work in Java?

• As stated earlier, the Queue interface extends the collection interface; hence, it supports all basic operational methods available in it.
• The implementations such as LinkedList and PriorityQueue implement the queue-specific methods declared in the Queue interface.
• The LinkedList holds the elements as the standard of LinkedList, i.e., in insertion order. The PriorityQueue maintains the natural order of inserted elements.
• Note that these two implementations are not thread-safe, and for this, Java provides another implementation named PriorityBlockingQueue, which is threaded-safe.

Queue Member Types in Java

• As the queue is an interface, it contains only abstract methods and no data members.
• The queue provides only a way to define the operations implemented in child classes.

Queue Functions in Java

• As the queue supports the FIFO structure, it allows the insertion of the elements from one end and removes the elements from another (front) end.
• These are the two basic operations that are supported by a queue.
• All the methods available in a queue can be divided into two categories; the first type of method throws an exception in case of failure of the operation, such as no element found, and in the second type of method, instead of the exception, any specific value such as null or false is returned in case of operation failure.
• A head in a queue concept always represents the first element in the queue; upon removal, this head element will be removed first.

Below are all the methods available in the queue:

	Returns special value	Throws exception
Insert	offer(e)	add(e)
Remove	poll()	remove()
Examine	peek()	element()

 

Returns special value

Throws exception

Insert

offer(e)

add(e)

Remove

poll()

remove()

Examine

peek()

element()

So as explained, two types of methods throw an exception and return a special value. There are three types of operation in this kind of operation: insertion, the second is removal, and the third is retrieval or examination. In the case of the remove operation, an object will be removed from the queue. Still, in the case of examination, the object will be returned without actually removing from the queue.

Examples of Queue in Java

Given below are the different examples of Queue in Java:

Example #1 – Add operation with LinkedList implementation

Code:

import java.util.LinkedList;
import java.util.Queue;
public class QueueOperations {
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<Integer> ();
q.add(5);
q.add(2);
q.add(1);
q.add(4);
q.add(3);
System.out.println(q);
}
}

Output:

Note here that the order of insertion is the same with output from left to write.

Example #2 – Let’s remove the added elements one by one

Code:

import java.util.LinkedList;
import java.util.Queue;
public class QueueOperations {
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<Integer> ();
q.add(5);
q.add(2);
q.add(1);
q.add(4);
q.add(3);
System.out.println(q);
while (!q.isEmpty()) {
System.out.print(q.remove() + " ");
}
System.out.println("");
System.out.println(q);
}
}

Output:

Here, we have used the function isEmpty() to check when the queue becomes empty after removing elements. The removal order is the same as per the insertion. After removing all the elements, we printed the queue and obtained an empty bracket at the end.

Example #3 – Insertion and Removal Operation on PriorityQueue

Code:

import java.util.PriorityQueue;
import java.util.Queue;
public class QueueOperations {
public static void main(String[] args) {
Queue<Integer> q = new PriorityQueue<Integer> ();
q.add(5);
q.add(2);
q.add(1);
q.add(4);
q.add(3);
System.out.println(q);
while (!q.isEmpty()) {
System.out.print(q.remove() + " ");
}
System.out.println("");
System.out.println(q);
}
}

Output:

Here, we have used PriorityQueue, which will hold and return the elements depending upon the elements’ natural ordering or upon the comparator, if any passed. Note the insertion order and removal orders are not the same. The removal is based totally on the value of elements.

Example #4 – Examine operation on LinkedList

Code:

import java.util.LinkedList;
import java.util.Queue;
public class QueueOperations {
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<Integer> ();
q.add(5);
q.add(2);
q.add(1);
q.add(4);
q.add(3);
System.out.println(q);
System.out.println( q.peek() );
System.out.println(q);
}
}

Output:

Note here that we have used the peek() function, which will return the head of the queue without actually removing it. We printed the queue after performing the peek operation, and you can observe that the head element, which is 5, remains unchanged in the queue.

Example #5 – Examine operation on PriorityQueue

Code:

import java.util.PriorityQueue;
import java.util.Queue;
public class QueueOperations {
public static void main(String[] args) {
Queue<Integer> q = new PriorityQueue<Integer> ();
q.add(5);
q.add(2);
q.add(1);
q.add(4);
q.add(3);
System.out.println(q);
System.out.println( q.peek() );
System.out.println(q);
}
}

Output:

This is similar to the previous example’s LinkedList operation, but note the head element is 1 because it’s a PriorityQueue.

Conclusion

Java utilizes the Queue interface as a means to maintain elements in insertion order. It supports operations like insertion, retrieval, and removal. There are alternative methods available for all the methods. We have seen examples of the most commonly used methods in queue operation.

The above is the detailed content of Queue in Java. For more information, please follow other related articles on the PHP Chinese website!