Queue in Java — All Types Explained

Think of people standing in a line at a ticket counter. The first person who joins is the first person served. This is called FIFO — First In, First Out.

// People join at the back
queue.offer("Alice");
queue.offer("Bob");
queue.offer("Carol");

// First out is Alice
queue.poll(); // Alice

Note: not every queue is strict FIFO. A PriorityQueue serves the highest priority item first, not always the oldest item.

Example: you try to remove an item, but the queue is empty.

• remove() throws an error (exception)
• poll() returns null — no crash

So the second column is not a different feature. It is the same action, written in a way that does not throw an exception. That is why we call it the safer option for beginners.

Tip: prefer offer, poll, and peek when the queue might be empty or full. Your program can check the result instead of crashing.

Queue<String> q = new LinkedList<>();
q.offer("Task-1");
q.offer("Task-2");

System.out.println(q.peek()); // Task-1 (still in queue)
System.out.println(q.poll()); // Task-1 (removed)
System.out.println(q.poll()); // Task-2
System.out.println(q.poll()); // null (empty)

Priority means: which item comes out first. You can define it in three simple ways.

1. Default priority (natural order)

For numbers, the smallest value has the highest priority. For strings, alphabetical order is used.

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(5);
pq.offer(1);
pq.offer(3);
System.out.println(pq.poll()); // 1  (smallest first)

2. Reverse priority (largest first)

Use Comparator.reverseOrder() when a bigger number should come out first.

PriorityQueue<Integer> pq =
        new PriorityQueue<>(Comparator.reverseOrder());

pq.offer(5);
pq.offer(1);
pq.offer(3);
System.out.println(pq.poll()); // 5  (largest first)

3. Custom priority with your own class

For real apps, store objects and decide priority with a field (for example: 1 = high, 2 = medium, 3 = low).

class Task {
    String name;
    int priority; // smaller number = higher priority

    Task(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }
}

PriorityQueue<Task> tasks = new PriorityQueue<>(
    (a, b) -> a.priority - b.priority  // compare by priority
);

tasks.offer(new Task("Send email", 3));
tasks.offer(new Task("Fix bug", 1));     // highest priority
tasks.offer(new Task("Write report", 2));

System.out.println(tasks.poll().name); // Fix bug
System.out.println(tasks.poll().name); // Write report
System.out.println(tasks.poll().name); // Send email

Simple rule: in (a, b) -> a.priority - b.priority, the smaller priority number comes out first. To reverse it, use (a, b) -> b.priority - a.priority.

A BlockingQueue can wait when it is empty (no item to take) or full (no space to add). Perfect for one thread producing work and another consuming it.

BlockingQueue<String> jobs = new ArrayBlockingQueue<>(3);
jobs.put("Job-1"); // waits if queue is full
jobs.put("Job-2");
String job = jobs.take(); // waits if empty → Job-1
System.out.println(job);

BlockingQueue<String> queue = new LinkedBlockingQueue<>();
queue.put("Task-A");
queue.put("Task-B");
System.out.println(queue.take()); // Task-A
System.out.println(queue.size()); // 1

BlockingQueue<Integer> pbq = new PriorityBlockingQueue<>();
pbq.put(50);
pbq.put(10);
pbq.put(30);
System.out.println(pbq.take()); // 10
System.out.println(pbq.take()); // 30

DelayQueue<DelayedTask> dq = new DelayQueue<>();
dq.put(new DelayedTask("Send email", 3)); // ready after 3 seconds
DelayedTask task = dq.take(); // waits until delay ends
System.out.println(task.getName()); // Send email

BlockingQueue<String> handoff = new SynchronousQueue<>();

// Thread 1: gives the item (waits for a taker)
new Thread(() -> {
    try {
        System.out.println("Giving item...");
        handoff.put("Hello");  // waits here until take() happens
        System.out.println("Item given");
    } catch (InterruptedException e) {}
}).start();

// Thread 2: takes the item (waits for a giver)
String msg = handoff.take();   // waits here until put() happens
System.out.println("Got: " + msg); // Got: Hello

LinkedTransferQueue<String> tq = new LinkedTransferQueue<>();
tq.offer("buffered-item");     // normal offer
boolean waiting = tq.hasWaitingConsumer();
tq.transfer("direct-item");    // waits for a consumer
System.out.println(tq.poll()); // buffered-item (if still present)

These queues are safe for many threads, but they do not wait. If the queue is empty, poll() returns null right away. The thread continues — it does not sleep or block.

Simple difference: blocking = wait for an item. Non-blocking = try now, get null if nothing is there. Both can be used by many threads safely.

ConcurrentLinkedQueue<String> q = new ConcurrentLinkedQueue<>();
q.offer("A");
q.offer("B");
System.out.println(q.poll()); // A
System.out.println(q.poll()); // B
System.out.println(q.poll()); // null (empty, no waiting)

ConcurrentLinkedDeque<String> dq = new ConcurrentLinkedDeque<>();
dq.offerFirst("front");
dq.offerLast("back");
System.out.println(dq.pollFirst()); // front
System.out.println(dq.pollLast());  // back

// Custom priority: larger number first
PriorityQueue<Integer> maxHeap =
    new PriorityQueue<>(Comparator.reverseOrder());

maxHeap.offer(3);
maxHeap.offer(9);
maxHeap.offer(1);
System.out.println(maxHeap.poll()); // 9

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

public class QueueDemo {
    public static void main(String[] args) {
        Queue<String> printJobs = new ArrayDeque<>();

        printJobs.offer("Invoice.pdf");
        printJobs.offer("Report.docx");
        printJobs.offer("Photo.png");

        while (!printJobs.isEmpty()) {
            String job = printJobs.poll();
            System.out.println("Printing: " + job);
        }
    }
}