Collections and Data Structures – Queues (Queue, PriorityQueue)

Introduction

Queues are a fundamental data structure in Java used to manage a collection of elements in a specific order. Two common queue implementations are ‘Queue’ and ‘PriorityQueue.’ In this guide, we’ll explore the world of queues in Java, understand the differences between ‘Queue’ and ‘PriorityQueue,’ and learn how to use them effectively in your Java applications.

Queue: Basic FIFO Structure

‘Queue’ is an interface in Java that represents a basic First-In-First-Out (FIFO) data structure. It defines the methods for adding, removing, and inspecting elements. Implementations of ‘Queue’ include ‘LinkedList’ and ‘ArrayDeque.’

Example – Using Queue

Here’s an example of creating and using a ‘Queue’ to manage a list of tasks to be processed in the order they are added:

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

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

        // Adding tasks to the Queue
        tasks.add("Task 1");
        tasks.add("Task 2");
        tasks.add("Task 3");

        // Processing tasks in FIFO order
        while (!tasks.isEmpty()) {
            String task = tasks.poll();
            System.out.println("Processing: " + task);
        }
    }
}

In this example, we create a ‘Queue’ of tasks and process them in the order they were added, following the FIFO principle.

PriorityQueue: Ordered Queue with Priority

‘PriorityQueue’ is another queue implementation in Java. It maintains elements in a specific order based on their natural order or a custom comparator. Elements are processed based on their priority, not necessarily in the order they were added.

Example – Using PriorityQueue

Here’s an example of creating and using a ‘PriorityQueue’ to manage a list of tasks with different priorities:

import java.util.PriorityQueue;
import java.util.Queue;

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

        // Adding tasks with different priorities
        tasks.add("High Priority Task");
        tasks.add("Low Priority Task");
        tasks add("Medium Priority Task");

        // Processing tasks based on priority
        while (!tasks.isEmpty()) {
            String task = tasks.poll();
            System.out.println("Processing: " + task);
        }
    }
}

In this example, we create a ‘PriorityQueue’ to manage tasks with different priorities. The tasks are processed based on their priority order, not necessarily in the order they were added.

Choosing Between Queue and PriorityQueue

The choice between ‘Queue’ and ‘PriorityQueue’ depends on your application’s requirements:

• ‘Queue’ is a better choice when:
  • You need to process elements in the order they are added (FIFO).
  • The order of processing is not based on priorities.
  • Elements should be processed in the same order they are added.
• ‘PriorityQueue’ is a better choice when:
  • You need to process elements based on their priority or a specific order.
  • The order of processing is based on priorities or natural order.
  • Elements have varying levels of importance or urgency.

Common Queue Operations

Both ‘Queue’ and ‘PriorityQueue’ provide common operations for managing elements:

• Adding Elements: Use the ‘add’ method to add elements to the queue. For ‘PriorityQueue,’ elements are ordered based on priority.
• Removing Elements: Use the ‘poll’ method to remove and retrieve the head of the queue. It returns ‘null’ for an empty queue.
• Checking for Existence: Use ‘isEmpty’ to check if the queue contains elements.
• Peeking at Elements: Use ‘peek’ to view the head of the queue without removing it.

Conclusion

Queues are essential for managing elements in a specific order, whether in FIFO or priority-based sequences. ‘Queue’ and ‘PriorityQueue’ are two valuable implementations, each serving distinct needs. By understanding their characteristics and use cases, you can efficiently manage data in your Java applications.