Queue Interface In Java

The Queue Interface is a part of java.util package and extends the Collection interface. It stores and processes the data in order means elements are inserted at the end and removed from the front.

Key Features:

• Most implementations, like PriorityQueue, do not allow null elements.
• Implementation Classes:
  • LinkedList
  • PriorityQueue
  • ArrayDeque
  • ConcurrentLinkedQueue (for thread-safe operations)
• Commonly used for task scheduling, message passing, and buffer management in applications.
• It supports iterating through elements. The order of iteration depends on the implementation.

Declaration of Java Queue Interface

The Queue interface is declared as:

public interface Queue extends Collection 

We cannot instantiate a Queue directly as it is an interface. Here, we can use a class like LinkedList or PriorityQueue that implements this interface.

Queue<Obj> queue = new LinkedList<Obj>();

Now let us go through a simple example first, then we will deep dive into the article.

Example: Basic Queue using LinkedList

// Java Program Implementing Queue Interface
import java.util.LinkedList;
import java.util.Queue;

public class Geeks {
    
  	public static void main(String args[]) 
    {
        // Create a Queue of Integers using LinkedList
        Queue<Integer> q = new LinkedList<>();
        
        // Displaying the Queue
        System.out.println("Queue elements: " + q);
    }
}

Queue elements: []

Being an interface the queue needs a concrete class for the declaration and the most common classes are the PriorityQueue and LinkedList in Java. Note that neither of these implementations is thread-safe. PriorityBlockingQueue is one alternative implementation if the thread-safe implementation is needed.

Creating Queue Objects

Queue is an interface, so objects cannot be created of the type queue. We always need a class which extends this list in order to create an object. And also, after the introduction of Generics in Java 1.5, it is possible to restrict the type of object that can be stored in the Queue. This type-safe queue can be defined as:

// Obj is the type of the object to be stored in Queue  Queue<Obj> queue = new PriorityQueue<Obj> (); 

In Java, the Queue interface is a subtype of the Collection interface and represents a collection of elements in a specific order. It follows the first-in, first-out (FIFO) principle. This means that the elements are retrieved in the order in which they were added to the queue.

Common Methods

The Queue interface provides several methods for adding, removing, and inspecting elements in the queue. Here are some of the most commonly used methods:

• add(element): Adds an element to the rear of the queue. If the queue is full, it throws an exception.
• offer(element): Adds an element to the rear of the queue. If the queue is full, it returns false.
• remove(): Removes and returns the element at the front of the queue. If the queue is empty, it throws an exception.
• poll(): Removes and returns the element at the front of the queue. If the queue is empty, it returns null.
• element(): Returns the element at the front of the queue without removing it. If the queue is empty, it throws an exception.
• peek(): Returns the element at the front of the queue without removing it. If the queue is empty, it returns null.

Example 1: This example demonstrates basic queue operations.

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

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

        // add elements to the queue
        queue.add("apple");
        queue.add("banana");
        queue.add("cherry");

        System.out.println("Queue: " + queue);

        // remove the element at the front of the queue
        String front = queue.remove();
        System.out.println("Removed element: " + front);

        // print the updated queue
        System.out.println("Queue after removal: " + queue);

        // add another element to the queue
        queue.add("date");

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

        // print the updated queue
        System.out.println("Queue after peek: " + queue);
    }
}

Queue: [apple, banana, cherry]
Removed element: apple
Queue after removal: [banana, cherry]
Peeked element: banana
Queue after peek: [banana, cherry, date]

Example 2:

// Java program to iterate a Queue
import java.util.LinkedList;
import java.util.Queue;

public class Geeks {

    public static void main(String[] args)
    {
        Queue<Integer> q
            = new LinkedList<>();

        // Adds elements {0, 1, 2, 3, 4} to
        // the queue
        for (int i = 0; i < 5; i++)
            q.add(i);

        // Display contents of the queue
        System.out.println("Elements of queue: "
                           + q);

        // To remove the head of queue
        int removedele = q.remove();
        System.out.println("Removed element:"
                           + removedele);

        System.out.println(q);

        // To view the head of queue
        int head = q.peek();
        System.out.println("Head of queue:"
                           + head);

        // Rest all methods of collection
        // interface like size and contains
        // can be used with this
        // implementation.
        int size = q.size();
        System.out.println("Size of queue:"
                           + size);
    }
}

Elements of queue: [0, 1, 2, 3, 4]
Removed element:0
[1, 2, 3, 4]
Head of queue:1
Size of queue:4

Different Operations on Queue Interface

Now let us see how to perform mostly used operations on the queue using the PriorityQueue class.

1. Adding Elements

To add an element in a queue, we can use the add() method. The insertion order is not retained in the PriorityQueue. The elements are stored based on the priority order which is ascending by default. 

Example:

// Java program to add elements
// to a Queue
import java.util.*;

public class Geeks {

    public static void main(String args[])
    {
        Queue<String> pq = new PriorityQueue<>();

        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");

        System.out.println(pq);
    }
}

[For, Geeks, Geeks]

2. Removing Elements

To remove an element from a queue, we can use the remove() method. If there are multiple objects, then the first occurrence of the object is removed. The poll() method is also used to remove the head and return it. 

Example:

// Java program to remove elements
// from a Queue
import java.util.*;

public class Geeks {

    public static void main(String args[])
    {
        Queue<String> pq = new PriorityQueue<>();

        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");

        System.out.println("Initial Queue: " + pq);

        pq.remove("Geeks");

        System.out.println("After Remove: " + pq);

        System.out.println("Poll Method: " + pq.poll());

        System.out.println("Final Queue: " + pq);
    }
}

Initial Queue: [For, Geeks, Geeks]
After Remove: [For, Geeks]
Poll Method: For
Final Queue: [Geeks]

3. Iterating the Queue

There are multiple ways to iterate through the Queue. The most famous way is converting the queue to the array and traversing using the for loop. The queue has also an inbuilt iterator which can be used to iterate through the queue. 

Example:

// Java program to iterate elements
// to a Queue
import java.util.*;

public class Geeks {

    public static void main(String args[])
    {
        Queue<String> pq = new PriorityQueue<>();

        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");

        Iterator iterator = pq.iterator();

        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }
}

For Geeks Geeks 

Characteristics of a Queue

The following are the characteristics of the queue:

• The Queue is used to insert elements at the end of the queue and removes from the beginning of the queue.
• The Java Queue supports all methods of Collection interface including insertion, deletion, etc.
• The Queues which are available in java.util package are Unbounded Queues.
• The Queues which are available in java.util.concurrent package are the Bounded Queues.
• All Queues except the Deque supports insertion and removal at the tail and head of the queue respectively. The Deque support element insertion and removal at both ends. 

Classes that implement the Queue Interface

1. PriorityQueue

PriorityQueue class which is implemented in the collection framework provides us a way to process the objects based on the priority. It is known that a queue follows the First-In-First-Out algorithm, but sometimes the elements of the queue are needed to be processed according to the priority, that’s when the PriorityQueue comes into play. Let’s see how to create a queue object using this class.

Example:

// Java program to demonstrate the
// creation of queue object using the
// PriorityQueue class
import java.util.*;

class Geeks {

    public static void main(String args[])
    {
        // Creating empty priority queue
        Queue<Integer> pq
            = new PriorityQueue<Integer>();

        // Adding items to the pQueue
        // using add()
        pq.add(10);
        pq.add(20);
        pq.add(15);

        // Printing the top element of
        // the PriorityQueue
        System.out.println(pq.peek());

        // Printing the top element and removing it
        // from the PriorityQueue container
        System.out.println(pq.poll());

        // Printing the top element again
        System.out.println(pq.peek());
    }
}

10
10
15

2. LinkedList

LinkedList is a class which is implemented in the collection framework which inherently implements the linked list data structure. It is a linear data structure where the elements are not stored in contiguous locations and every element is a separate object with a data part and address part. The elements are linked using pointers and addresses. Let’s see how to create a queue object using this class.

Example:

// Java program to demonstrate the
// creation of queue object using the
// LinkedList class
import java.util.*;

class Geeks {

    public static void main(String args[])
    {
        // Creating empty LinkedList
        Queue<Integer> ll
            = new LinkedList<Integer>();

        // Adding items to the ll
        // using add()
        ll.add(10);
        ll.add(20);
        ll.add(15);

        // Printing the top element of
        // the LinkedList
        System.out.println(ll.peek());

        // Printing the top element and removing it
        // from the LinkedList container
        System.out.println(ll.poll());

        // Printing the top element again
        System.out.println(ll.peek());
    }
}

10
10
20

3. PriorityBlockingQueue

PriorityBlockingQueue is one alternative implementation if thread-safe implementation is needed. PriorityBlockingQueue is an unbounded blocking queue that uses the same ordering rules as class PriorityQueue and supplies blocking retrieval operations. It is unbounded, adding elements may sometimes fail due to resource exhaustion resulting in OutOfMemoryError. Let’s see how to create a queue object using this class.

Example:

// Java program to demonstrate the
// creation of queue object using the
// PriorityBlockingQueue class
import java.util.concurrent.PriorityBlockingQueue;
import java.util.*;

class Geeks {
    public static void main(String args[])
    {
        // Creating empty priority
        // blocking queue
        Queue<Integer> pbq
            = new PriorityBlockingQueue<Integer>();

        // Adding items to the pbq
        // using add()
        pbq.add(10);
        pbq.add(20);
        pbq.add(15);

        // Printing the top element of
        // the PriorityBlockingQueue
        System.out.println(pbq.peek());

        // Printing the top element and
        // removing it from the
        // PriorityBlockingQueue
        System.out.println(pbq.poll());

        // Printing the top element again
        System.out.println(pbq.peek());
    }
}

10
10
15

Methods of Queue Interface

The queue interface inherits all the methods present in the collections interface while implementing the following methods:

Advantages

• The Queue interface provides a way to store and retrieve elements in a specific order, following the first-in, first-out (FIFO) principle.
• The Queue interface is a subtype of the Collection interface. It means that it can be used with many different data structures and algorithms, depending on the requirements of the application.
• Some implementations of the Queue interface, such as the java.util.concurrent.ConcurrentLinkedQueue class, are thread-safe, which means that they can be accessed by multiple threads simultaneously without causing conflicts.

Disadvantages

• The Queue interface is designed specifically for managing collections of elements in a specific order, which means that it may not be suitable for more complex data structures or algorithms.
• Some implementations of the Queue interface, such as the ArrayDeque class, have a fixed size, which means that they cannot grow beyond a certain number of elements.
• Depending on the implementation, the Queue interface may require more memory than other data structures, if it needs to store additional information about the order of the elements.

kartik

Follow

Improve

Article Tags :

• Java
• Java-Collections
• java-queue

Practice Tags :

• Java
• Java-Collections