Java集合类对比：ArrayList与LinkedList源码解析

1. 项目概述

作为一名Java开发者，ArrayList和LinkedList这两个集合类我们几乎每天都在使用。但你真的了解它们的底层实现差异吗？今天我们就来彻底拆解JDK 1.8中这两个核心集合类的源码实现，通过对比分析它们的存储结构、增删改查性能、内存占用等关键指标，帮助你在实际开发中做出更合理的选择。

2. 核心数据结构对比

2.1 ArrayList的数组实现

ArrayList底层使用Object[]数组存储元素，我们来看关键源码：

java复制transient Object[] elementData; // 存储数组
private int size; // 当前元素数量

初始化时默认创建长度为10的数组（无参构造器）：

java复制public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

当数组容量不足时，会触发扩容：

java复制private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5倍扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

关键点：ArrayList的扩容是代价较高的操作，涉及数组拷贝。建议在已知数据量时通过构造函数指定初始容量。

2.2 LinkedList的链表实现

LinkedList采用双向链表结构，节点定义如下：

java复制private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;
    // 构造方法...
}

实际存储通过首尾指针维护：

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

每个新元素插入都会创建新的Node对象：

java复制void linkLast(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++;
}

3. 关键操作性能对比

3.1 随机访问性能

ArrayList的get()操作是O(1)复杂度：

java复制public E get(int index) {
    rangeCheck(index);
    return elementData(index); // 直接数组下标访问
}

LinkedList的get()需要遍历链表，最坏情况O(n)：

java复制public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

Node<E> node(int index) {
    // 根据index决定从头还是从尾开始遍历
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

3.2 插入删除性能

ArrayList在中间插入需要移动元素：

java复制public void add(int index, E element) {
    rangeCheckForAdd(index);
    modCount++;
    final int s;
    Object[] elementData;
    if ((s = size) == (elementData = this.elementData).length)
        elementData = grow();
    System.arraycopy(elementData, index, elementData, index + 1, s - index);
    elementData[index] = element;
    size = s + 1;
}

LinkedList在已知位置插入只需修改指针，O(1)复杂度：

java复制public void add(int index, E element) {
    checkPositionIndex(index);
    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

4. 内存占用分析

4.1 ArrayList内存模型

• 每个ArrayList实例占用：

  • 对象头：12字节（32位JVM）或16字节（64位JVM）
  • elementData数组引用：4字节
  • size计数器：4字节
  • modCount计数器：4字节
  • 对齐填充：可能4字节
  • 总计：约24-32字节

• 元素存储：

  • 每个数组槽位存储对象引用：4字节
  • 未使用的槽位也会占用空间

4.2 LinkedList内存模型

• 每个Node节点占用：

  • 对象头：12/16字节
  • item引用：4字节
  • next/prev引用：各4字节
  • 总计：约24-28字节/节点

• LinkedList实例本身：

  • 类似ArrayList，约24-32字节
  • first/last引用：各4字节

实测对比：存储100万个Integer对象时，ArrayList比LinkedList节省约40%内存

5. 迭代器实现差异

5.1 ArrayList迭代器

基于数组下标实现，支持快速随机访问：

java复制private class Itr implements Iterator<E> {
    int cursor; // 当前下标
    int lastRet = -1; // 最后返回的下标
    int expectedModCount = modCount;
    
    public boolean hasNext() {
        return cursor != size;
    }
    
    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        Object[] elementData = ArrayList.this.elementData;
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }
}

5.2 LinkedList迭代器

基于链表节点遍历：

java复制private class ListItr implements ListIterator<E> {
    private Node<E> lastReturned;
    private Node<E> next;
    private int nextIndex;
    private int expectedModCount = modCount;
    
    public boolean hasNext() {
        return nextIndex < size;
    }
    
    public E next() {
        checkForComodification();
        lastReturned = next;
        next = next.next;
        nextIndex++;
        return lastReturned.item;
    }
}

6. 实际应用场景建议

6.1 优先使用ArrayList的情况

1. 频繁随机访问（get/set操作）
2. 数据量可预估且变化不大
3. 内存敏感场景
4. 需要序列化传输时（ArrayList的数组序列化效率更高）

6.2 优先使用LinkedList的情况

1. 频繁在头部/中间插入删除
2. 需要实现队列/双端队列操作
3. 数据量变化剧烈且不可预测
4. 不需要频繁随机访问

6.3 性能实测数据对比

7. 常见问题与优化技巧

7.1 ArrayList优化

1. 预分配足够容量：

java复制// 已知要存储5000个元素时
List list = new ArrayList(5000);

2. 避免频繁扩容：

java复制// 添加大量元素前先扩容
list.ensureCapacity(minCapacity);

3. 使用trimToSize释放多余空间：

java复制list.trimToSize(); // 将容量调整为当前size

7.2 LinkedList优化

1. 使用专门的队列方法：

java复制// 优于add/remove
offer(), poll(), peek()

2. 批量操作时考虑使用迭代器：

java复制ListIterator it = list.listIterator();
while(it.hasNext()) {
    // 批量处理
}

3. 避免使用size()方法：

java复制// LinkedList的size()需要遍历计数
while(!list.isEmpty()) { ... }

8. 线程安全考虑

两者都不是线程安全的，常见解决方案：

1. Collections.synchronizedList：

java复制List syncList = Collections.synchronizedList(new ArrayList());

2. CopyOnWriteArrayList（适合读多写少）：

java复制List cowList = new CopyOnWriteArrayList();

3. 手动加锁：

java复制synchronized(list) {
    list.add(item);
}

对于LinkedList，在多线程环境下更推荐使用：

java复制ConcurrentLinkedQueue // 并发队列
LinkedBlockingQueue // 阻塞队列