Java ArrayDeque 与 LinkedList 的区别？

在 Java 中，ArrayDeque 和 LinkedList 都实现了 Deque 接口，并且都可以用来实现队列和双端队列的功能。然而，两者在底层实现、性能和使用场景上有显著的不同。

ArrayDeque 与 LinkedList 的基本区别

1. 底层实现

• ArrayDeque：基于可变长的数组和双指针来实现。
• LinkedList：基于双向链表来实现。

2. 支持的元素

• ArrayDeque：不支持存储 null 数据。
• LinkedList：支持存储 null 数据。

3. 引入版本

• ArrayDeque：在 JDK 1.6 中被引入。
• LinkedList：早在 JDK 1.2 中就已经存在。

4. 插入性能

• ArrayDeque：插入时可能存在扩容过程，但均摊后的插入操作依然为 O(1)。
• LinkedList：每次插入数据时均需要申请新的堆空间，均摊性能相比更慢。

源码解析

ArrayDeque 的实现

ArrayDeque 基于循环数组来实现，可以通过源码来理解其设计。

java

public class ArrayDeque<E> extends AbstractCollection<E>
        implements Deque<E>, Cloneable, Serializable {
    private transient E[] elements; // 存储元素的数组
    private transient int head; // 队头索引
    private transient int tail; // 队尾索引

    public ArrayDeque() {
        elements = (E[]) new Object[16]; // 默认容量为16
    }

    public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[head = (head - 1) & (elements.length - 1)] = e;
        if (head == tail)
            doubleCapacity();
    }

    public void addLast(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[tail] = e;
        if ((tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
    }

    private void doubleCapacity() {
        // 扩容逻辑
    }
}

设计原理

ArrayDeque 通过一个循环数组和两个指针（head 和 tail）来实现双端队列。插入操作在队头和队尾都可以通过简单的指针操作完成。

扩容机制：当数组容量不足时，ArrayDeque 会调用 doubleCapacity 方法进行扩容。扩容后，数组的容量会翻倍，并重新调整已有元素的位置。

LinkedList 的实现

LinkedList 基于双向链表实现，每个节点包含上一个节点和下一个节点的引用。

java

public class LinkedList<E> extends AbstractSequentialList<E>
        implements List<E>, Deque<E>, Cloneable, Serializable {
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

    transient int size = 0;
    transient Node<E> first;
    transient Node<E> last;

    public void addFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
    }

    public void addLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
    }
}

设计原理

LinkedList 通过节点（Node）来存储元素，每个节点包含前后两个节点的引用（prev 和 next）。插入和删除操作通过调整节点的引用来实现。

插入操作：在队头插入时，创建一个新的节点，并将其前置于当前第一个节点之前；在队尾插入时，创建一个新的节点，并将其附加在当前最后一个节点之后。

性能比较

插入和删除操作

• ArrayDeque：插入和删除操作通常为 O(1)，但在扩容时会有 O(n) 的开销。
• LinkedList：插入和删除操作为 O(1)，但需要分配新的节点，涉及到内存分配和垃圾回收。

随机访问操作

• ArrayDeque：支持随机访问，时间复杂度为 O(1)。
• LinkedList：不支持高效的随机访问，时间复杂度为 O(n)。

实际案例

使用 ArrayDeque 实现栈

由于 ArrayDeque 的插入和删除性能较高，因此它适合作为栈的实现。

java

public class StackUsingArrayDeque {
    private ArrayDeque<Integer> stack;

    public StackUsingArrayDeque() {
        stack = new ArrayDeque<>();
    }

    public void push(int value) {
        stack.addLast(value);
    }

    public int pop() {
        return stack.removeLast();
    }

    public int peek() {
        return stack.peekLast();
    }

    public boolean isEmpty() {
        return stack.isEmpty();
    }
}

使用 LinkedList 实现队列

LinkedList 适合用来实现队列，尤其是在需要频繁插入和删除的场景下。

java

public class QueueUsingLinkedList {
    private LinkedList<Integer> queue;

    public QueueUsingLinkedList() {
        queue = new LinkedList<>();
    }

    public void enqueue(int value) {
        queue.addLast(value);
    }

    public int dequeue() {
        return queue.removeFirst();
    }

    public int peek() {
        return queue.peekFirst();
    }

    public boolean isEmpty() {
        return queue.isEmpty();
    }
}

总结

• ArrayDeque：适用于需要高效插入和删除操作的场景，不支持存储 null 数据，扩容时会有一定的性能开销。
• LinkedList：适用于需要频繁插入和删除操作的场景，支持存储 null 数据，但不适合随机访问。

在选择数据结构时，应根据具体的需求和使用场景来决定是使用 ArrayDeque 还是 LinkedList。