性能对决：LinkedList vs ArrayList，结果出乎意料

nice01qc2024-04-21 9:55

jdk版本：1.8

在工作中经常使用 LinkedList 和 ArrayList，但是什么情况下该使用 LinkedList，什么情况下该使用 ArrayList；由于LinkedList底层存储是链表结构，ArrayList 底层是数组结构。通常建议 是ArrayList适合随机访问，LinkedList适合插入和删除操作，真的是这样的吗 ，通过单机测试发现这个建议不是很合理 ，以下是我测试LinkedList和 ArrayList 的 内存容量占用、get耗时、add耗时、remove耗时、迭代遍历耗时对比结果。

内存占用分析

这里使用了lucene工具进行计算集合内存占用。

lucene jar包引入

xml 复制代码 
<dependencies>
    <dependency>
        <groupId>org.apache.lucene</groupId>
        <artifactId>lucene-core</artifactId>
        <version>4.0.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.12.0</version>
    </dependency>

内存占用分析Java代码

java 复制代码 
List<Object> list = new LinkedList<>();
List<Object> arrayList = new ArrayList<>();

int size = 1;
for (int i = 0; i < 23; i++) {
    // 指数级增加容量
    size = size * 2;
    for (int j = 0; j < size; j++) {
        list.add(new Object());
        arrayList.add(new Object());
    }
    System.out.println("capacity size:" + size + ",[LinkedList, ArrayList]:[" + RamUsageEstimator.humanSizeOf(list) 
            + "," + RamUsageEstimator.humanSizeOf(arrayList) + "]");
    list.clear();
    arrayList.clear();
}

运行结果：

用二维图展示：

小结论

LinkedList 因为是链表结构，每个节点都需要封装成Node里面，自然占用更多的内存空间，从上面数据可以看出LinkedList占用的存储空间几乎是ArrayList的两倍；

get耗时分析

这个没什么悬念，LinkedList 每次get都是从链表头开始寻找，而ArrayList底层是数组，可直接计算出存储位置，所以LinkedList get耗时远超ArrayList。

get耗时分析Java代码

java 复制代码 
List<Integer> list = new LinkedList<>();
List<Integer> arrayList = new ArrayList<>();

int size = 1;
for (int j = 1; j < 18; j++) {
    size = size * 2;
    for (int i = 0; i < size; i++) {
        list.add(i);
    }

    long listBegin = System.nanoTime();
    for (int i = 0; i < size; i++) {
        list.get(i);
    }
    double listCost = (System.nanoTime() - listBegin) / 1000000.0;
    System.out.print("lists size: " + size + "; get cost time[LinkedList, ArrayList]:[" + listCost);
    list.clear();

    for (int i = 0; i < size; i++) {
        arrayList.add(i);
    }
    long arrayListBegin = System.nanoTime();
    for (int i = 0; i < size; i++) {
        arrayList.get(i);
    }
    double arrayCost = (System.nanoTime() - arrayListBegin) / 1000000.0;
    System.out.println("ms, " + arrayCost + "ms]");
    arrayList.clear();
}

用二维图展示：

小结论

LinkedList get 复杂度是o(n), ArrayList 是o(1)。

add耗时分析

LinkedList add是在链表尾部追加；ArrayList 是在数字最后追加，如果超过容量阈值存在扩容；表象看LinkedList add会更快些，因为不需要扩容，实际测试结果却不是这样。

add耗时分析Java代码

java 复制代码 
List<Integer> list = new LinkedList<>();
List<Integer> arrayList = new ArrayList<>();

int size = 1;

for (int j = 1; j < 11; j++) {
    size = size * 5;
    long listBegin = System.nanoTime();
    for (int i = 0; i < size; i++) {
        list.add(i);
    }
    System.out.print("lists size: " + size + "; add cost time[LinkedList, ArrayList]:[" + (System.nanoTime() - listBegin) / 1000000.0);
    list.clear();

    long arrayListBegin = System.nanoTime();
    for (int i = 0; i < size; i++) {
        arrayList.add(i);
    }
    System.out.println("ms, " + (System.nanoTime() - arrayListBegin) / 1000000.0 + "ms]");
    arrayList.clear();
}

用二维图展示：

小结论

随着集合容量的增加，LinkedList add累计耗时直线上升，ArrayList add累计耗时上升很慢；LinkedList 慢的原因应该是每次add一个值都需要封装成Node然后追加到链表尾部，每次封装Node（实例化Node对象）的耗时不容小觑；ArrayList add 不需要封装，影响耗时的只有扩容，而每次扩容都是调用底层System.arraycopy 数组拷贝，这个拷贝函数内存复制执行很快，而且每次扩容int newCapacity = oldCapacity + (oldCapacity >> 1); 为原容量的1.5倍，所以随着容量增加其实扩容不了几次，这也是ArrayList add速度快的原因。

remove耗时分析

remove过程为 找到需要移除值位置，然后删除；LinkedList 找到位置后只需要操作指针便可，而 ArrayList 找到所在位置后需要使用System.arraycopy 移除数组所在位置值。

remove耗时分析Java代码

java 复制代码 
List<Integer> list = new LinkedList<>();
List<Integer> arrayList = new ArrayList<>();

int size = 1;

for (int j = 1; j < 16; j++) {
    size = size * 2;
    // 集合LinkedList初始化
    for (int i = 0; i < size; i++) {
        list.add(i);
    }

    long listBegin = System.nanoTime();
    // 开始随机移除
    for (int i = 0; i < size; i++) {
        list.remove(Integer.valueOf(getRandomValue(size)));
    }
    double listCost = (System.nanoTime() - listBegin) / 1000000.0;
    System.out.print("lists size: " + size + "; random remove time[LinkedList, ArrayList]:[" + listCost);
    list.clear();
    
    // 集合ArrayList初始化
    for (int i = 0; i < size; i++) {
        arrayList.add(i);
    }
    long arrayListBegin = System.nanoTime();
    // 开始随机移除
    for (int i = 0; i < size; i++) {
        arrayList.remove(Integer.valueOf(getRandomValue(size)));
    }
    double arrayCost = (System.nanoTime() - arrayListBegin) / 1000000.0;
    System.out.println("ms, " + arrayCost + "ms]");
    arrayList.clear();
}

用二维图展示：

小结论

测试运行了10次以上，二维图变化不大，可信度很高。

从二维图可以看出 ArrayList remove 耗时几乎比 LinkedList 快7 倍；之所以这么快应该是ArrayList遍历比LinkedList遍历要更快，而且 ArrayList 使用System.arraycopy 移除效率是真的很高。

迭代遍历耗时分析

iterator 是每个集合通用功能

迭代遍历耗时分析Java代码

ini 复制代码 
List<Integer> list = new LinkedList<>();
List<Integer> arrayList = new ArrayList<>();

int size = 1;

for (int j = 1; j < 25; j++) {
    size = size * 2;
    // 集合LinkedList初始化
    for (int i = 0; i < size; i++) {
        list.add(i);
    }

    long listBegin = System.nanoTime();
    Iterator<Integer> iterator = list.iterator();
    while (iterator.hasNext()) {
        iterator.next();
    }
    double listCost = (System.nanoTime() - listBegin) / 1000000.0;
    System.out.print("lists size: " + size + "; get cost time[LinkedList, ArrayList]:[" + listCost);
    list.clear();

    // 集合ArrayList初始化
    for (int i = 0; i < size; i++) {
        arrayList.add(i);
    }
    long arrayListBegin = System.nanoTime();
    Iterator<Integer> arrayListIterator = arrayList.iterator();
    while (arrayListIterator.hasNext()) {
        arrayListIterator.next();
    }
    double arrayCost = (System.nanoTime() - arrayListBegin) / 1000000.0;
    System.out.println("ms, " + arrayCost + "ms]");
    arrayList.clear();
}

用二维图展示：

小结论

ArrayList 的遍历速度远快于 LinkedList 的遍历，看后面数据，几乎快了100倍，原因有以下2点：

  1. 内存结构 ：ArrayList 是基于动态数组实现的，而 LinkedList 是基于双向链表实现的。在 ArrayList 中，元素存储在连续的内存空间中，这使得内存访问更加高效。相比之下，LinkedList 中的元素是分散存储的，每个元素都需要一个额外的存储空间来保存指向前一个和后一个元素的引用，这增加了内存访问的开销。
  2. 遍历方式 ：在遍历 ArrayList 时，由于元素存储的连续性，CPU缓存（如L1、L2缓存）可以更有效地工作，因为相邻的数据更可能被一起加载到缓存中。而 LinkedList 由于元素不连续，导致缓存的局部性原理得不到充分利用，降低了缓存命中率。

性能对比结论

ArrayList 相对于 LinkedList内存容量占用更低，get、add、remove、迭代遍历效率更高， LinkedList 性能方面完败。

使用建议

ArrayList各方面性能完胜LinkedList，如果比较在意性能问题，建议使用ArrayList；那什么情况下可以使用LinkedList ，如果你不在意性能，且经常需要在集合头尾增加或者移除元素，还是使用LinkedList好些，代码可读性更好些，可看以下使用。

java 复制代码 
LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.addLast(value); // 头部添加元素
linkedList.addFirst(value); // 尾部添加元素
linkedList.removeFirst(); // 移除头部元素
linkedList.removeLast();// 移除尾部元素
linkedList.getFirst();// 获取头部元素
linkedList.getLast();// 获取尾部元素

ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(0, value); // 头部添加元素
arrayList.add(arrayList.size() -1, value); // 尾部添加元素，且需要判断集合是否为空
arrayList.remove(0); // 移除头部元素，且需要判断集合是否为空
arrayList.remove(arrayList.size() -1);// 移除尾部元素，且需要判断集合是否为空
arrayList.get(0); // 获取头部元素，且需要判断集合是否为空
arrayList.get(arrayList.size() -1); // 获取尾部元素，且需要判断集合是否为空
相关推荐
devilnumber3 分钟前
避坑_IDEA 提取方法（Extract Method）工具
java·ide·intellij-idea
鬼手点金17 分钟前
Agent 的学习机制：后训练、上下文学习与外部化学习
java·人工智能·git·学习·自动化·nanogpt
小陈不好吃27 分钟前
equals 与 hashCode 的契约关系：从 HashMap 到 Lombok 注解
java·hashmap·lombok
tianbin91142 分钟前
大模型训练与推理：API中转站在企业AI落地中的隐藏价值
大数据·后端·ai
xiaogai_gai1 小时前
金蝶收料通知单查询策略实战教程：从源系统拉取到中间层落地的完整路径
java·前端·数据库
打工仔折腾 AI1 小时前
用 Dashlet 把极空间 NAS 服务入口整理成统一导航首页的实践
java·开发语言·人工智能·后端·python·rpc·ai agent 实战
环境栈笔记2 小时前
指纹浏览器 WebRTC 怎么设置？从 ICE 候选、代理出口到功能验证
前端·人工智能·后端·自动化
一只小猪妖2 小时前
分布式唯一 性ID生成方法
后端
小蒜学长2 小时前
微信小程序-高校自习室管理系统（代码+数据库+LW）
java·spring boot·后端·微信小程序·自习室管理
热门推荐
01「全语录+省流版」邵艾伦 × 孙宇晨：聊风口、聊个人IP、聊年轻人如何抓住 AI 时代的机会02国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）03GitHub 镜像站点04历年考研数学一、数学二、数学三真题试卷及答案PDF05几个好用的ip纯净度检测网站06蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接07Telegram APK 下载安装完整指南 — 2026年最新08Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）09苹果iPA游戏软件资源下载网站10微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新