为什么我应该使用 Deque over Stack 和 LinkedList over Queue？

Question

When I learn about Stack and Queue, It uses a stack/queue over an ArrayList. However, I search the API by Intellij, Stack and Queue use ArrayDeque class in a list collection, not ArrayList.

  /**
  * <p>A more complete and consistent set of LIFO stack operations is
   * provided by the {@link Deque} interface and its implementations, which
  * should be used in preference to this class.  For example:
  * <pre>   {@code   *   Deque<Integer> stack = new ArrayDeque<Integer>();}
  */

In Queue, It uses LinkedList class in the LinkedList API. and also Most people's codes like:

Queue<Integer> q1 = new LinkedList<>()

/**
 * Queue operations.
 * Retrieves, but does not remove, the head (first element) of this list.
 *
 * @return the head of this list, or {@code null} if this list is empty
 * @since 1.5
 */

The point is, when it explains about the concept, Stack and Queue, use ArrayList.

But, in reality, use LinkedList or ArrayDeque, not ArrayList. Would you explain why?

Answer 1

Most of this question is specific to Java, but the part about using an array-list as a queue is more general.

---

In Java specifically, you should use an ArrayDeque or another deque implementation instead of the Stack class: according to the documentation,

A more complete and consistent set of LIFO stack operations is provided by the Deque interface and its implementations, which should be used in preference to this class.

Another reason to prefer ArrayDeque for most use-cases is that Stack extendsVector , which is a synchronized implementation. Synchronization has a performance penalty, and is unnecessary when the stack will only be accessed from a single thread (ie almost all of the time).

An ArrayDeque is better than an ArrayList as a stack, because to simulate the pop method on an ArrayList you have to write s.remove(s.size() - 1) , which is inconvenient and less clear.

---

The reason you should use a LinkedList "instead of" a Queue is because Queue is an interface, not a class, so you simply can't write new Queue<>() to create a queue; this will give a compilation error.

Note that it's still best to declare the type of your variable as Queue<...> .

---

The reason you shouldn't use an ArrayList as a queue is more general: it is a dynamic array data structure , so it only supports add and remove operations in O(1) time at one end. Adding or removing at the other end takes O(n) time. So it is unsuitable to use as a queue because a queue should enqueue and poll at different ends, and the operation at one end will be inefficient compared to other more suitable queue data structures.