当前位置：首页 > news >正文

Java 中 ArrayList 与 LinkedList 的深度对比：从原理到实战选择

news 2025/9/18 7:21:27

在 Java 集合框架中，ArrayList和LinkedList是两种常用的线性表实现，都继承自List接口，但内部结构和性能特性却有显著差异。本文将从数据结构、核心操作性能、内存占用等方面进行深度对比，并结合实际场景给出选择建议，帮助开发者在项目中做出更合理的选择。

一、底层数据结构差异

1. ArrayList 的数组实现

ArrayList基于动态数组实现，其内部维护一个Object[]数组来存储元素。当元素数量超过数组容量时，会自动触发扩容机制：

初始容量默认为 10（JDK8）
扩容时创建新数组（原容量的 1.5 倍），并将旧数组元素复制到新数组
通过索引（index）直接访问元素，类似数组的随机访问特性

核心源码片段（简化）：

public class ArrayList<E> {transient Object[] elementData; // 存储元素的数组private int size; // 当前元素数量// 添加元素时的扩容逻辑private void grow(int minCapacity) {int oldCapacity = elementData.length;int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5倍扩容elementData = Arrays.copyOf(elementData, newCapacity);}
}

2. LinkedList 的双向链表实现

LinkedList基于双向链表实现，每个元素封装为Node节点，包含前驱指针（prev）、后继指针（next）和实际元素（item）：

无需预设容量，元素增减时只需调整指针指向
不支持随机访问，需从表头 / 表尾开始遍历
内部维护first（头节点）和last（尾节点）指针

核心源码片段（简化）：

public class LinkedList<E> {transient Node<E> first; // 头节点transient Node<E> last;  // 尾节点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;}}
}

二、核心操作性能对比

1. 随机访问（get (int index)）

ArrayList：通过索引直接访问数组元素，时间复杂度为O(1)，性能优异
LinkedList：需从表头 / 表尾开始遍历至目标索引，时间复杂度为O(n)，元素越多性能越差

测试验证（百万级元素）：

// 随机访问性能测试
List<Integer> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<>();// 初始化数据（省略）long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {arrayList.get(i * 100); // 随机访问
}
System.out.println("ArrayList耗时：" + (System.currentTimeMillis() - start) + "ms"); // 约1msstart = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {linkedList.get(i * 100); // 随机访问
}
System.out.println("LinkedList耗时：" + (System.currentTimeMillis() - start) + "ms"); // 约500ms

2. 新增元素（add ()）

尾部添加（add (E e)）：
- ArrayList：若无需扩容，直接添加至数组尾部，O (1)；若需扩容，涉及数组复制，O (n)
- LinkedList：直接在尾节点后新增节点，O (1)（通过 last 指针直接操作）
指定位置添加（add (int index, E e)）：
- ArrayList：需移动 index 后的所有元素，O (n)
- LinkedList：找到目标位置后只需调整指针，O (n)（查找耗时为主，插入本身 O (1)）

3. 删除元素（remove ()）

按索引删除（remove (int index)）：
- ArrayList：删除后需移动后续元素填补空位，O (n)
- LinkedList：查找目标节点后调整指针，O (n)（同样是查找耗时）
按元素删除（remove (Object o)）：
- 两者均需先遍历找到元素（O (n)），区别在于后续操作：
  - ArrayList：删除后移动元素（O (n)）
  - LinkedList：删除后调整指针（O (1)）

4. 遍历性能

for 循环（通过索引）：
- ArrayList：性能优异（O (1) 访问）
- LinkedList：性能极差（每次 get (index) 都是从头遍历）
增强 for 循环（迭代器）：
- 两者性能接近，均通过Iterator遍历，时间复杂度 O (n)
- LinkedList 的迭代器（ListItr）通过指针移动，效率更高

三、内存占用对比

ArrayList：
- 内存连续分配，空间利用率高
- 存在扩容预留空间（可能浪费部分内存）
- 每个元素直接存储值，无额外指针开销
LinkedList：
- 每个元素需额外存储 prev 和 next 指针（约 16 字节 / 节点，64 位 JVM）
- 节点分散存储，可能导致更多的 GC 开销
- 总内存占用通常高于 ArrayList（元素数量越多差距越大）

四、实战选择建议

根据上述特性，实际开发中可遵循以下原则

优先选择 ArrayList 的场景：
- 需要频繁随机访问元素（如通过索引查询）
- 新增 / 删除操作主要在集合尾部
- 元素数量固定或变化不大（可预设初始容量减少扩容）
优先选择 LinkedList 的场景：
- 频繁在集合中间位置进行插入 / 删除操作
- 无需随机访问，仅需顺序遍历
- 元素数量动态变化大，且无法预估容量
特殊注意事项：
- 当元素数量极小时（<100），两者性能差异可忽略
- 频繁的 ArrayList 扩容会导致性能波动，建议通过new ArrayList(int initialCapacity)预设容量
- 遍历 LinkedList 时，避免使用普通 for 循环（通过索引访问），推荐迭代器或增强 for 循环