Java Queue: LinkedList, PriorityQueue, and Real-World Patterns

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

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.add("Alice");
        queue.add("Bob");
        queue.add("Charlie");

        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
    }
}

Alice Bob Charlie

What is a Java Queue?

A Java Queue is a collection of objects that are processed in a First-In-First-Out (FIFO) order. Think of a queue like a line of people waiting for a concert - the first person in line is the first one to get in. Queues are everywhere in real code - message systems, thread pools, BFS. And yet most tutorials make them boring. Not this one.

Queue Interface

The Queue interface in Java is a part of the Java Collections Framework. It provides methods for common queue operations like adding, removing, and peeking at elements.

import java.util.Queue;

public interface Queue<E> {
    boolean add(E e);
    boolean offer(E e);
    E remove();
    E poll();
    E element();
    E peek();
}

Implementing a Java Queue with LinkedList

One of the most common ways to implement a queue in Java is by using a LinkedList.

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

public class Main {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.add("Alice");
        queue.add("Bob");
        queue.add("Charlie");

        System.out.println(queue.poll()); // Alice
        System.out.println(queue.peek()); // Bob
    }
}

Alice Bob

PriorityQueue - A Special Kind of Java Queue

A PriorityQueue is a special kind of queue where elements are ordered based on their priority.

import java.util.PriorityQueue;

public class Main {
    public static void main(String[] args) {
        PriorityQueue<Integer> queue = new PriorityQueue<>();
        queue.add(5);
        queue.add(1);
        queue.add(10);

        System.out.println(queue.poll()); // 1
        System.out.println(queue.poll()); // 5
    }
}

1 5

ArrayDeque - A Better Java Queue?

An ArrayDeque is a resizable-array implementation of the Deque interface. It's often faster and more efficient than a LinkedList.

import java.util.ArrayDeque;

public class Main {
    public static void main(String[] args) {
        ArrayDeque<String> queue = new ArrayDeque<>();
        queue.add("Alice");
        queue.add("Bob");
        queue.add("Charlie");

        System.out.println(queue.poll()); // Alice
        System.out.println(queue.poll()); // Bob
    }
}

Alice Bob

BlockingQueue - A Java Queue for Multi-Threading

A BlockingQueue is a queue that blocks when it's empty or full. It's designed for multi-threading scenarios where one thread produces elements and another thread consumes them.

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>();
        queue.put("Alice");
        queue.put("Bob");
        queue.put("Charlie");

        System.out.println(queue.take()); // Alice
        System.out.println(queue.take()); // Bob
    }
}

Alice Bob

Offer vs Add - What's the Difference?

Both offer and add methods are used to add elements to a queue. However, offer returns false when the queue is full, while add throws an exception.

Real-World Uses of Java Queues

Java queues are used in many real-world applications, including:

Breadth-First Search (BFS) algorithms
Task scheduling systems
Message queues
Thread pools

Java queues are a powerful tool for any Java developer. Whether you're building a complex algorithm or a simple task scheduling system, queues can help you get the job done.

Want to convert your Java code to another programming language? Try CodeConverter today!

Code Converter