Java集合大PK：ArrayList vs LinkedList - 谁才是你的真命天子？-CSDN博客

本文链接：https://blog.csdn.net/qq_35971258/article/details/147838736

大家好呀！👋 今天我们要来聊一聊Java集合中两个最常用的"明星选手" - ArrayList和LinkedList。它们就像是班级里的两个学霸，各有各的特长，但很多同学却傻傻分不清楚。

📚 第一章：先认识一下两位选手

ArrayList - 数组小能手 📊

ArrayList就像是一个会自动扩容的"智能数组"。想象一下你有一个装糖果的盒子🍬，一开始盒子不大，但随着你不断往里面放糖果，盒子会自动变大，永远不用担心装不下！

ArrayList candyBox = new ArrayList<>();
candyBox.add("巧克力");
candyBox.add("棒棒糖");
// 盒子会自动变大哦！

LinkedList - 链条小达人 🔗

LinkedList则像是一串珍珠项链，每颗珍珠都通过小链条连接在一起。你想在哪加珍珠都可以，只需要改变一下前后珍珠的连接方式就行啦！

LinkedList pearlNecklace = new LinkedList<>();
pearlNecklace.add("白珍珠");
pearlNecklace.add("黑珍珠");
// 可以轻松在任意位置插入新珍珠

🔍 第二章：内部结构大揭秘

ArrayList的内心世界 🧐

ArrayList心里其实住着一个数组：

// 简化版的ArrayList内部
public class ArrayList {
    private Object[] elementData; // 核心数组
    private int size; // 当前元素数量
}

初始容量一般是10，就像你新买了一个能装10颗糖的盒子。当盒子满了，它会自动买个更大的盒子(通常是1.5倍大小)，然后把所有糖搬过去。🔄

LinkedList的小心思 🤫

LinkedList的内心是由一个个"小车厢"组成的：

// 简化版的Node内部类
private static class Node {
    E item;        // 当前元素
    Node next;  // 下一个车厢
    Node prev;  // 前一个车厢
}

每个元素都知道自己的"左邻右舍"，就像小朋友们手拉手做游戏一样。👫👬👭

⚡ 第三章：性能大比拼

1. 访问元素速度 🏎️

ArrayList：像查字典一样快！📖 直接翻到第N页，因为它是数组实现的。

// ArrayList获取第5个元素 - 闪电速度！
candyBox.get(5);

LinkedList：像玩寻宝游戏，必须从第一个开始数。🔍 “第一个知道第二个，第二个知道第三个…”

// LinkedList获取第5个元素 - 要数5次
pearlNecklace.get(5);

🏆 胜利者：ArrayList！访问元素时间复杂度O(1) vs LinkedList的O(n)

2. 插入/删除元素速度 ✂️

在末尾添加：

ArrayList：通常很快，除非需要扩容
LinkedList：总是很快，因为记得最后一个元素

在中间插入：

ArrayList：要把后面的元素都往后挪，像排队插队
LinkedList：只需要改变前后元素的指针，像重新拉手

// ArrayList在中间插入
candyBox.add(3, "新糖果"); // 后面的糖果都要移动

// LinkedList在中间插入
pearlNecklace.add(3, "新珍珠"); // 只需要改变前后珍珠的链接

在开头插入：

ArrayList：所有元素都要往后移
LinkedList：超级快，只需要改第一个元素的指针

🏆 胜利者：LinkedList！在非末尾位置插入/删除时间复杂度O(1) vs ArrayList的O(n)

3. 内存占用比较 💾

ArrayList：

只比实际需要的空间多一点(扩容预留)
浪费主要在扩容时的临时空间

LinkedList：

每个元素都要多存两个指针(前后节点)
对于小对象，可能指针比数据还占空间

🏆 胜利者：ArrayList！通常占用更少内存

📊 第四章：详细性能对比表

操作	ArrayList	LinkedList
获取元素(get)	⚡O(1)	🐢O(n)
末尾添加(add)	⚡O(1) (通常)	⚡O(1)
中间插入(add)	🐢O(n)	⚡O(1)
开头插入(addFirst)	🐢O(n)	⚡O(1)
末尾删除(removeLast)	⚡O(1)	⚡O(1)
中间删除(remove)	🐢O(n)	⚡O(1)
开头删除(removeFirst)	🐢O(n)	⚡O(1)
内存占用	🏆更少	更多
迭代性能	⚡更快	🐢稍慢

💡 第五章：什么时候用谁？

请选择ArrayList当… 📌

你经常要随机访问元素（比如get(5)）
你的操作主要在列表末尾进行（添加/删除）
你需要节省内存空间
你需要遍历列表多次

典型场景：购物车商品列表、学生成绩列表

请选择LinkedList当… 🖇️

你经常在列表开头/中间插入删除
你需要实现队列/双端队列(LinkedList实现了Deque接口)
列表大小变化非常大且频繁
你不怎么需要随机访问元素

典型场景：音乐播放列表、浏览器历史记录、撤销操作栈

🛠️ 第六章：实战代码示例

ArrayList实战 🏗️

// 创建ArrayList
ArrayList students = new ArrayList<>();

// 添加元素
students.add("张三");
students.add("李四");
students.add(1, "王五"); // 在索引1插入

// 访问元素
String topStudent = students.get(0);

// 遍历 - 普通for循环
for(int i=0; i songList = new LinkedList<>();

// 添加元素
songList.add("晴天");
songList.addFirst("七里香"); // 添加到开头
songList.addLast("夜曲");   // 添加到末尾
songList.add(2, "简单爱");  // 在索引2插入

// 实现队列操作
songList.offer("稻香");     // 添加到末尾
String firstSong = songList.poll(); // 移除并返回第一个元素

// 遍历 - 迭代器
Iterator it = songList.iterator();
while(it.hasNext()) {
    System.out.println(it.next());
}

🧐 第七章：高级知识点

1. 初始容量与扩容 📈

ArrayList可以指定初始容量，避免频繁扩容：

// 创建一个初始容量为100的ArrayList
ArrayList bigClass = new ArrayList<>(100);

扩容是个耗时的操作(要创建新数组并拷贝元素)，所以如果能预估大小，提前设置容量能提升性能！🚀

2. 并发修改异常 ⚠️

在使用迭代器遍历时，如果直接用集合的add/remove方法修改集合，会抛出ConcurrentModificationException：

ArrayList list = new ArrayList<>(Arrays.asList("A","B","C"));

// 错误示范 ❌
for(String s : list) {
    if(s.equals("B")) {
        list.remove(s); // 抛出异常！
    }
}

// 正确做法 ✅
Iterator it = list.iterator();
while(it.hasNext()) {
    if(it.next().equals("B")) {
        it.remove(); // 安全删除
    }
}

3. 随机访问接口 🎯

ArrayList实现了RandomAccess接口(一个标记接口)，而LinkedList没有。这个接口没有任何方法，只是用来标记"支持快速随机访问"。

在需要判断时可以使用：

if(list instanceof RandomAccess) {
    // 使用for循环遍历
} else {
    // 使用迭代器遍历
}

🤔 第八章：常见误区与陷阱

误区1：LinkedList在任何情况下插入都快 ❌

虽然LinkedList在理论上中间插入是O(1)，但实际找到插入位置需要O(n)时间(除非使用ListIterator)。所以如果随机位置插入，可能不比ArrayList快多少！

误区2：ArrayList插入一定慢 ❌

对于尾部插入，ArrayList通常比LinkedList更快，因为：

不需要创建新节点
内存连续，CPU缓存友好

误区3：LinkedList更省内存 ❌

对于小对象，LinkedList通常占用更多内存，因为每个元素都要存储前后指针(每个指针在32位JVM占4字节，64位占8字节)。

🏳️ 第九章：总结与最终建议

经过这场精彩的PK，我们来总结一下两位选手的特点：