🚀 Java Collections - Understanding Queue Interface with Real-World Use Cases

Series: Java Collections Framework | Part 2 – Queue

Hello Devs! 👋
Welcome to the second blog in my Java Collections Framework series. After exploring the Set interface, we’re now diving into the Queue interface, which is another essential part of the Java Collections Framework. In this post, we’ll understand the core concepts of the Queue, its types, real-world examples, and use cases.

---

🧠 What is a Queue in Java?

A Queue is a first-in, first-out (FIFO) data structure where the first element added is the first one to be removed. It models a queue in real life, like a line at a ticket counter or people waiting at a bus stop.

Key Features:

• Follows FIFO order.

• Offers operations to add elements (offer()), remove elements (poll()), and inspect elements (peek()).

• Can store null elements (in most implementations).

---

💡 Real-World Problem Statement

“Imagine you’re building a task scheduling system where tasks are executed in the order they are received. We need to ensure that the tasks are processed in the exact order they are added.”

---

🔧 Use Case 1: Task Scheduling System

Solution: Use LinkedList as Queue

🔸 Queue Interface:

• The Queue interface is implemented by classes like LinkedList, PriorityQueue, and others.

• It’s designed to hold a collection of elements, where elements are processed in a FIFO manner.

The most common implementation of Queue is LinkedList, which allows efficient insertion and removal of elements at both ends.

✅ Code Example:

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

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

        // Adding tasks to the queue
        taskQueue.offer("Task 1: Analyze requirements");
        taskQueue.offer("Task 2: Design the system");
        taskQueue.offer("Task 3: Implement the solution");
        taskQueue.offer("Task 4: Test the solution");

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

📌 Output:

Processing: Task 1: Analyze requirements
Processing: Task 2: Design the system
Processing: Task 3: Implement the solution
Processing: Task 4: Test the solution

✅ The tasks are processed in the exact order they were added to the queue.

---

🔧 Use Case 2: Priority Task Scheduling

Solution: Use PriorityQueue

🔸 PriorityQueue:

• A PriorityQueue is a special type of queue where elements are processed based on their priority rather than the order they were added.

• The highest-priority elements are dequeued first.

• It does not guarantee FIFO order but rather orders elements according to their natural ordering or by a custom comparator.

✅ Code Example:

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

public class PriorityTaskScheduler {
    public static void main(String[] args) {
        // Creating a priority queue where tasks have priorities
        Queue<String> taskQueue = new PriorityQueue<>((task1, task2) -> task1.length() - task2.length());

        // Adding tasks with varying lengths (this will act as priority)
        taskQueue.offer("Short task");
        taskQueue.offer("Very long task that needs to be done");
        taskQueue.offer("Medium task");

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

📌 Output:

Processing: Short task
Processing: Medium task
Processing: Very long task that needs to be done

✅ The shortest task is processed first, showcasing how priority is handled.

---

🔧 Use Case 3: Task Management with Circular Queue

Solution: Use ArrayDeque

🔸 ArrayDeque:

• ArrayDeque implements the Queue interface and can be used as both a stack and a queue.

• It does not have the limitations of a traditional Queue as it resizes dynamically and allows both ends to be accessed for insertion and removal.

✅ Code Example:

import java.util.ArrayDeque;
import java.util.Queue;

public class CircularQueueExample {
    public static void main(String[] args) {
        Queue<String> taskQueue = new ArrayDeque<>(3); // Initial capacity of 3

        // Adding tasks to the queue
        taskQueue.offer("Task 1");
        taskQueue.offer("Task 2");
        taskQueue.offer("Task 3");

        // Removing one task and adding another
        taskQueue.poll();
        taskQueue.offer("Task 4");

        // Display the remaining tasks
        System.out.println("Remaining Tasks: " + taskQueue);
    }
}

📌 Output:

Remaining Tasks: [Task 2, Task 3, Task 4]

✅ This illustrates a circular queue where after removing the first element, a new one can be added at the end.

---

🔍 When to Use Which Queue?

---

🎯 Summary

• Queue is essential for maintaining the FIFO order of elements.

• Use LinkedList for general-purpose queues, PriorityQueue for tasks with different priorities, and ArrayDeque for circular queues.

• These types help in solving task scheduling, priority task management, and circular buffering problems effectively.

---

🚀 Coming Up Next

In the next part of this series, we’ll explore the Deque interface and its implementations like ArrayDeque and LinkedList, used for both stack and queue operations.

Stay tuned, and let me know in the comments if you’d like me to cover a specific topic!
Happy coding! 😄