Java中Queue为何使用LinkedList构造方法初始化？

Great question—this is a common point of confusion when first diving into Java's collection framework, so let's unpack it clearly.

Why use LinkedList to initialize Queue? #

First, remember that Queue is just an interface—it defines the contract for queue operations (like offer(), poll(), peek()), but doesn't provide any implementation logic. You need a concrete class that implements this interface to create a usable queue instance.

LinkedList is a popular choice here because:

• It implements the Deque interface (which extends Queue), so it already has all the required queue operations built-in out of the box.
• Its underlying structure is a doubly linked list. For core queue operations (adding to the tail, removing from the head), this structure is highly efficient: both offer() (add to end) and poll() (remove from start) are O(1) operations—no need to shift elements around, just update a few pointers.
• Compare this to ArrayList: if you tried to use it as a queue, removing the first element (poll()) would require shifting every remaining element left by one position, which is an O(n) operation. That's terrible for performance, especially with large queues.

Can you implement a Queue using ArrayList? #

Absolutely! You just need to create a class that implements the Queue interface and uses ArrayList as its backing storage. Here's a quick, functional example:

import java.util.ArrayList;
import java.util.Queue;

public class ArrayListQueue<E> extends ArrayList<E> implements Queue<E> {

    @Override
    public boolean offer(E e) {
        // Add element to the end of the list (queue tail)
        return add(e);
    }

    @Override
    public E poll() {
        // Remove and return the first element (queue head)
        if (isEmpty()) {
            return null;
        }
        return remove(0);
    }

    @Override
    public E peek() {
        // Return the first element without removing it
        if (isEmpty()) {
            return null;
        }
        return get(0);
    }

    // For full Queue interface compliance, you'd also implement methods like remove(), element()
    // but the above covers the core queue operations
}

That said, this implementation isn't ideal for most real-world use cases because of the poor performance of remove(0) as mentioned earlier. Java's standard library actually provides ArrayDeque—a much better array-based queue implementation that avoids this issue by using a circular buffer, making both head and tail operations O(1).

So while using ArrayList is technically possible, it's not recommended for performance-critical scenarios. Stick with LinkedList or ArrayDeque for standard queue needs.

内容的提问来源于stack exchange，提问作者abhigyan nayak