Different Java Queue Classes

The Queue interface in Java is implemented by multiple classes, each with different behaviors. Here’s a detailed comparison of all Queue implementations:

1. LinkedList<E> (Implements both Queue and Deque)

  • Underlying Data Structure: Doubly Linked List.
  • Order: ✅ Maintains insertion order.
  • Duplicates: ✅ Allowed.
  • Null Values: ✅ Allowed.
  • Time Complexity:
  • O(1) for insertion/deletion at head/tail.
  • O(n) for random access.
  • Best Use Case: When you need a FIFO queue but also require List functionalities.

🔹 Example:

Queue<Integer> queue = new LinkedList<>();
queue.offer(10);
queue.offer(20);
queue.offer(30);
System.out.println(queue.poll()); // Output: 10 (FIFO order)

✅ Pros:

  • Can be used as both Queue (FIFO) and Deque (Double-ended).
  • Efficient insertions and deletions.

❌ Cons:

  • More memory overhead due to linked list structure.
  • Slower random access.

2. PriorityQueue<E> (Implements Queue)

  • Underlying Data Structure: Binary Heap (Min-Heap by default).
  • Order: ❌ No insertion order, elements are sorted by priority.
  • Duplicates: ✅ Allowed.
  • Null Values: ❌ Not allowed.
  • Time Complexity:
  • O(log n) for insertion and deletion.
  • O(1) for retrieval of the highest-priority element.
  • Best Use Case: When elements must be processed based on priority rather than order.

🔹 Example:

Queue<Integer> pq = new PriorityQueue<>();
pq.offer(30);
pq.offer(10);
pq.offer(20);
System.out.println(pq.poll()); // Output: 10 (smallest element first)

✅ Pros:

  • Automatic ordering of elements.
  • Efficient for priority-based tasks.

❌ Cons:

  • Cannot store null values.
  • Not suitable for simple FIFO queues.

3. ArrayDeque<E> (Implements Deque, Faster than LinkedList)

  • Underlying Data Structure: Resizable Array.
  • Order: ✅ Maintains insertion order.
  • Duplicates: ✅ Allowed.
  • Null Values: ❌ Not allowed.
  • Time Complexity:
  • O(1) for insertions and deletions from both ends.
  • Best Use Case: When both FIFO and LIFO (stack-like) behavior is needed with better performance than LinkedList.

🔹 Example:

Queue<Integer> queue = new ArrayDeque<>();
queue.offer(10);
queue.offer(20);
queue.offer(30);
System.out.println(queue.poll()); // Output: 10 (FIFO order)

✅ Pros:

  • Faster than LinkedList for Queue and Deque operations.
  • Efficient for both stack and queue operations.

❌ Cons:

  • Cannot store null values.

4. PriorityBlockingQueue<E> (Thread-Safe Version of PriorityQueue)

  • Underlying Data Structure: Binary Heap.
  • Order: ✅ Sorted order based on priority.
  • Duplicates: ✅ Allowed.
  • Null Values: ❌ Not allowed.
  • Thread-Safe?: ✅ Yes (internally synchronized).
  • Time Complexity:
  • O(log n) for insertion and deletion.
  • Best Use Case: When multiple threads need to process elements based on priority.

🔹 Example:

Queue<Integer> pq = new PriorityBlockingQueue<>();
pq.offer(30);
pq.offer(10);
pq.offer(20);
System.out.println(pq.poll()); // Output: 10 (smallest element first)

✅ Pros:

  • Thread-safe.
  • Elements are sorted by priority.

❌ Cons:

  • Unbounded, so might consume too much memory if not managed properly.

5. LinkedBlockingQueue<E> (Thread-Safe FIFO Queue)

  • Underlying Data Structure: Linked List.
  • Order: ✅ Maintains FIFO order.
  • Duplicates: ✅ Allowed.
  • Null Values: ❌ Not allowed.
  • Thread-Safe?: ✅ Yes (internally synchronized).
  • Time Complexity:
  • O(1) for insertions and deletions.
  • Best Use Case: When a thread-safe FIFO queue is required.

🔹 Example:

Queue<Integer> queue = new LinkedBlockingQueue<>();
queue.offer(10);
queue.offer(20);
queue.offer(30);
System.out.println(queue.poll()); // Output: 10 (FIFO order)

✅ Pros:

  • Thread-safe.
  • Bounded or unbounded (optional limit).

❌ Cons:

  • Slower than ArrayDeque due to synchronization overhead.

6. ArrayBlockingQueue<E> (Thread-Safe Bounded Queue)

  • Underlying Data Structure: Array.
  • Order: ✅ Maintains FIFO order.
  • Duplicates: ✅ Allowed.
  • Null Values: ❌ Not allowed.
  • Thread-Safe?: ✅ Yes.
  • Time Complexity:
  • O(1) for insertions and deletions.
  • Best Use Case: When a fixed-size, thread-safe FIFO queue is required.

🔹 Example:

Queue<Integer> queue = new ArrayBlockingQueue<>(2);
queue.offer(10);
queue.offer(20);
System.out.println(queue.poll()); // Output: 10 (FIFO order)

✅ Pros:

  • Thread-safe.
  • Bounded queue prevents excessive memory usage.

❌ Cons:

  • Needs a fixed size at initialization.

Comparison Table

When to Use Which?

  • Use LinkedList when you need a simple FIFO queue.
  • Use PriorityQueue when elements must be processed based on priority.
  • Use ArrayDeque when you need a faster queue (better than LinkedList).
  • Use PriorityBlockingQueue for thread-safe priority queues.
  • Use LinkedBlockingQueue for thread-safe FIFO queues.
  • Use ArrayBlockingQueue when you need a bounded, thread-safe FIFO queue.

📚 Want to go deeper?

Grab these resources: 🛒 Full Editions (use code FRIENDS20 for 20% off):

Grokking the Java Interview: link
Grokking the Spring Boot Interview: link
250+ Spring Professional Certification Practice Questions: link

🆓 Try before you buy — Free Sample Copies:

Grokking the Java Interview [Free Sample Copy]
Grokking the Spring Boot Interview [Free Sample Copy]
Spring Boot Certification Practice Questions [Free Sample Copy]

Different Java Queue Classes was originally published in Javarevisited on Medium, where people are continuing the conversation by highlighting and responding to this story.

This post first appeared on Read More

Related Posts