Pages

Topics

Tools

↑↓navigate↵openescclose
All guides

Using LinkedList as a Queue in Java

Use LinkedList as a Queue in Java: learn add/offer, remove/poll, peek, FIFO behavior, performance tradeoffs, and when to prefer ArrayDeque.

~6 min readJava
#LinkedList#Queue Interface#Java Collections#Deque
A diagram showing a Java LinkedList used as a FIFO queue with elements entering at the tail and leaving at the head.

When you need a first-in, first-out structure in Java, the Queue interface defines the contract, and LinkedList is a common implementation. This article explains the API, the FIFO behavior, and the performance and design considerations that matter in real applications.

The Queue Contract Implemented by LinkedList

The Queue interface is part of java.util. It defines operations for adding elements, removing elements, and inspecting the front of the queue. LinkedList implements List and Deque, and because Deque extends Queue, a LinkedList can behave as a queue, a double-ended queue, or a list, depending on how you use it.

For FIFO (first-in, first-out) semantics, you add elements at the tail and remove them from the head. LinkedList maintains references to both its first and last nodes, so adding at the tail and removing from the head are both constant-time operations.

java
import java.util.LinkedList; import java.util.Queue; Queue<String> taskQueue = new LinkedList<>(); taskQueue.add("parse-config"); taskQueue.add("load-cache"); taskQueue.add("warm-connections"); String next = taskQueue.remove(); // "parse-config"

In this example, remove() retrieves and removes the head of the queue. The next call to remove() would return "load-cache". The queue preserves insertion order, which is exactly what FIFO requires.

Essential Queue Methods and Their Edge Cases

The Queue interface groups operations into three categories: insertion, removal, and inspection. Each operation has two variants: one that throws an exception and one that returns a special value (null or false).

OperationThrows ExceptionReturns Special Value
Insertadd(e)offer(e)
Removeremove()poll()
Inspectelement()peek()

For LinkedList, the add and offer methods behave identically because the queue does not have a capacity limit (other than memory). Similarly, remove() and poll() both remove the head, but remove() throws NoSuchElementException if the queue is empty, while poll() returns null. The same distinction applies to element() and peek().

java
Queue<String> queue = new LinkedList<>(); System.out.println(queue.peek()); // null System.out.println(queue.element()); // throws NoSuchElementException

Choosing between these variants depends on how you want to handle empty conditions. If an empty queue is a programmer error, remove() and element() will surface the problem immediately. If an empty queue is a normal state (for example, a work queue that is occasionally idle), poll() and peek() are safer because they return null without disrupting control flow.

Iterating Without Consuming the Queue

A queue is typically consumed by repeatedly removing elements, but there will be times when you need to inspect its contents without changing them. LinkedList supports iteration directly because it is also a List. You can use an enhanced for loop or an iterator.

java
Queue<String> queue = new LinkedList<>(); queue.offer("one"); queue.offer("two"); for (String value : queue) { System.out.println(value); }

This iteration visits elements from head to tail. The queue remains intact after the loop. This is useful for logging, auditing, or debugging, but be careful: if you simply want to drain the queue, poll() in a loop is the intended approach.

Performance Characteristics of LinkedList as a Queue

LinkedList offers O(1) insertion at the tail and O(1) removal at the head, both with no resizing or shifting. That sounds ideal for a queue, and it is for many cases. However, there are hidden costs related to memory locality and allocation.

Each element is stored in a separate node object that holds the value plus two references (next and previous). This means higher memory overhead per element compared to an array-backed structure. Also, the nodes can be scattered in heap memory, so traversing the queue involves following references, which can be cache-unfriendly. In practice, for very large queues, an array-based deque like ArrayDeque often performs better due to better locality and fewer allocations, even though it occasionally resizes.

The performance difference becomes observable in high-throughput scenarios where the queue is constantly being filled and drained. ArrayDeque has no fixed capacity limit and grows as needed, but when it resizes, it copies the underlying array. LinkedList avoids copying, but it allocates a new node for each inserted element, which adds GC pressure. There is no universal winner; the choice depends on the workload.

Choosing Between LinkedList and ArrayDeque

If you only need queue semantics, ArrayDeque is usually a better default than LinkedList. The ArrayDeque class implements Deque and provides a resizable-array double-ended queue. It does not allow null elements and is not index-based, which is usually fine for queue use.

Consider these decision criteria:

  • Use LinkedList when the same object must also satisfy the List API—for example, when it is passed to code that expects a List—or when you need a queue that permits null elements. Remember that LinkedList's indexed access is O(n), so it is not suited to index-heavy list workloads.
  • Use ArrayDeque when you need a pure queue or stack, because it often has lower memory overhead and better cache performance.
  • Use PriorityQueue when elements must be ordered by priority rather than insertion order.

For most queue-only scenarios, ArrayDeque is the better default. However, there are valid reasons to use LinkedList, especially when your object is being passed to code that expects a List, or when you are already using LinkedList elsewhere and want to share the instance.

Avoiding Common Errors with LinkedList as a Queue

One frequent mistake is using add and remove without accounting for their exception behavior. If your queue is being drained by multiple threads, a simple remove() will throw NoSuchElementException if another thread already consumed the last element. poll() is a safer choice for such concurrent access, although even poll() is not sufficient for true thread safety. LinkedList is not thread-safe; concurrent modification requires external synchronization or a thread-safe queue implementation like ConcurrentLinkedQueue.

Another error is assuming that LinkedList guarantees ordering beyond insertion order. As a Deque, LinkedList supports addFirst, addLast, removeFirst, and removeLast. When you use those methods, you are no longer following FIFO semantics. Mixing queue methods with deque methods on the same instance can lead to confusing behavior.

java
Deque<String> deque = new LinkedList<>(); deque.addLast("first"); deque.addFirst("zeroth"); System.out.println(deque.removeFirst()); // "zeroth"

If your code clearly uses a Queue reference, you are unlikely to call these methods, but if you hold a LinkedList reference, the method set is larger, and a small change can silently alter the data structure's behavior.

Production Considerations and Alternative Queue Implementations

For single-threaded or externally synchronized use, LinkedList and ArrayDeque are both viable. In multi-threaded contexts, the standard LinkedList is not safe. Even if you wrap it with Collections.synchronizedList, that only synchronizes each individual method; compound actions like check-then-act are still not atomic. For concurrent producers and consumers, consider ConcurrentLinkedQueue (lock-free, FIFO) or the blocking queues in java.util.concurrent, such as LinkedBlockingQueue or ArrayBlockingQueue.

LinkedBlockingQueue is interesting because it uses linked nodes (similar to LinkedList) but includes thread-safe operations and optional bounds. If you need a bounded FIFO queue for a producer–consumer pattern, LinkedBlockingQueue is a direct alternative. Its linked nature avoids array copying on resizing, but it does allocate a node per element.

A practical production decision is to choose the queue implementation based on the dominant operation. A queue that is filled once and drained once, such as a batch job queue, may not need the fastest possible throughput. A queue that is processed continuously at high frequency benefits from an array-backed structure. In both cases, measure under your actual workload rather than relying on general assumptions about LinkedList versus ArrayDeque performance.

In summary, LinkedList can serve as a Queue because Deque extends Queue, and it offers reliable FIFO behavior with constant-time head and tail operations. The main limitations are memory overhead and cache behavior, which matter most when the queue is large or allocated frequently. For most queue usage, ArrayDeque is a solid default, but LinkedList remains a legitimate choice when list features are needed alongside queue operations. Ensure that you select the exception-throwing or value-returning method variants that match your empty-queue handling strategy, and remember that LinkedList is not thread-safe.

Try matching browser tools

All tools

Small utilities that fit Java work — they run entirely in this browser tab, so nothing you paste leaves your device.

All Java guides

More in Java

All Java guides

The guides filed next to this one in Java, in library order.