TL；DR由于现代计算机体系结构，ArrayList对于几乎所有可能的用例都将显著提高效率，因此除了一些非常独特和极端的情况外，应避免使用LinkedList。

理论上，LinkedList的add（E元素）有一个O（1）

此外，在列表中间添加元素应该非常有效。

实践非常不同，因为LinkedList是一个缓存敌对数据结构。从性能POV来看，LinkedList很少比缓存友好的ArrayList性能更好。

以下是在随机位置插入元素的基准测试结果。如您所见，数组列表效率更高，但理论上，每次在列表中间插入都需要“移动”数组后面的n个元素（值越低越好）：

使用新一代硬件（更大、更高效的缓存），结果更为确凿：

LinkedList需要更多的时间来完成相同的任务。源源代码

这主要有两个原因：

主要是LinkedList的节点在内存中随机分布。RAM（“随机存取存储器”）不是真正随机的，需要将内存块提取到缓存中。此操作需要时间，并且当此类提取频繁发生时，缓存中的内存页需要一直被替换->缓存未命中->缓存效率不高。ArrayList元素存储在连续内存中——这正是现代CPU架构正在优化的目标。Secondary LinkedList需要保留/转发指针，这意味着与ArrayList相比，每个存储值的内存消耗是3倍。

顺便说一句，DynamicIntArray是一个自定义ArrayList实现，它保存Int（原始类型）而不是Object，因此所有数据都是相邻存储的，因此效率更高。

需要记住的一个关键因素是，获取存储块的成本比访问单个存储单元的成本更重要。这就是为什么读卡器1MB的顺序存储器比从不同内存块读取此数据量快x400倍的原因：

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD
Read 1 MB sequentially from memory     250,000   ns      250 us
Round trip within same datacenter      500,000   ns      500 us
Read 1 MB sequentially from SSD*     1,000,000   ns    1,000 us    1 ms  ~1GB/sec SSD, 4X memory
Disk seek                           10,000,000   ns   10,000 us   10 ms  20x datacenter roundtrip
Read 1 MB sequentially from disk    20,000,000   ns   20,000 us   20 ms  80x memory, 20X SSD
Send packet CA->Netherlands->CA    150,000,000   ns  150,000 us  150 ms

来源：每个程序员都应该知道的延迟数

为了让这一点更加清晰，请检查在列表开头添加元素的基准。这是一个用例，从理论上讲，LinkedList应该非常出色，而ArrayList应该呈现出糟糕甚至更糟糕的用例结果：

注意：这是C++标准库的一个基准测试，但我以前的经验表明C++和Java的结果非常相似。源代码

复制连续的大量内存是一种由现代CPU改变理论优化的操作，实际上也使ArrayList/Vector更加高效

致谢：这里发布的所有基准都是由Kjell Hedström创建的。在他的博客上可以找到更多的数据

是的，我知道，这是一个古老的问题，但我会投入我的两分钱：

LinkedList在性能方面几乎总是错误的选择。有一些非常具体的算法需要LinkedList，但这些算法非常非常罕见，并且该算法通常具体取决于LinkedLists在使用ListIterator导航到列表中间后相对快速地插入和删除元素的能力。

有一个常见的用例LinkedList优于ArrayList：队列。但是，如果您的目标是性能，那么您也应该考虑使用ArrayBlockingQueue（如果您可以提前确定队列大小的上限，并且能够提前分配所有内存），而不是LinkedList，或者使用CircularArray实现。（是的，它来自2001年，因此您需要对其进行一般化，但我得到的性能比与最近一篇JVM文章中引用的性能比相当）

让我们将LinkedList和ArrayList与以下参数进行比较：

1.实施

ArrayList是列表接口的可调整大小的数组实现，而LinkedList是列表接口的双重链接列表实现。

2.性能

get（int索引）或搜索操作ArrayList get（int索引）操作在恒定时间内运行，即O（1）而LinkedList get（int索引）操作运行时间为O（n）。ArrayList比LinkedList更快的原因是ArrayList对其元素使用基于索引的系统，LinkedList不为其元素提供基于索引的访问，因为它从开始或结束（以较近者为准）迭代以检索指定元素索引处的节点。insert（）或add（Object）操作与ArrayList相比，LinkedList中的插入通常很快。在LinkedList中，添加或插入是O（1）操作。在ArrayList中，如果数组已满（即最坏情况），则调整数组大小并将元素复制到新数组会产生额外的成本，这使得ArrayList的加法运算运行时为O（n），否则为O（1）。删除（int）操作LinkedList中的移除操作通常与ArrayList相同，即O（n）。在LinkedList中，有两个重载的移除方法。一个是remove（），没有任何参数，它会删除列表的头部，并在恒定时间O（1）内运行。LinkedList中的另一个重载remove方法是remove（int）或remove（Object），它删除作为参数传递的Object或int。此方法遍历LinkedList，直到找到Object并将其从原始列表中取消链接。因此，该方法运行时为O（n）。在ArrayList中，remove（int）方法涉及将元素从旧数组复制到新的更新数组，因此其运行时为O（n）。

3.反向迭代器

LinkedList可以使用descendingIterator（）反向迭代，同时ArrayList中没有descendingIterator（），因此我们需要编写自己的代码以反向遍历ArrayList。

4.初始容量

如果构造函数没有重载，那么ArrayList将创建一个初始容量为10的空列表，而LinkedList只构建没有任何初始容量的空列表。

5.内存开销

与ArrayList相比，LinkedList中的内存开销更大，因为LinkedList的节点需要维护下一个和上一个节点的地址。虽然在ArrayList中，每个索引仅保存实际对象（数据）。

来源

到目前为止，除了人们普遍认为LinkedList比ArrayList“多得多”之外，似乎没有人解决这些列表中每一个的内存占用问题，所以我做了一些数字处理，以证明这两个列表对于N个空引用所占的空间。

由于引用在其相对系统上是32位或64位（即使为空），因此我为32位和64位LinkedList和ArrayList包含了4组数据。

注意：ArrayList行显示的大小是用于修剪列表的-实际上，ArrayList中的后备数组的容量通常大于其当前元素计数。

注2：（感谢BeeOnRope）由于压缩Oops现在是默认值，从JDK6中期开始，以下64位机器的值将基本上与32位机器的对应值相匹配，当然，除非您特意关闭它。

结果清楚地表明，LinkedList比ArrayList多得多，尤其是元素数非常高的情况。如果内存是一个因素，请避开LinkedList。

我使用的公式如下，如果我做错了什么，请告诉我，我会改正的对于32位或64位系统，b’是4或8，而n’是元素的数量。注意mods的原因是因为java中的所有对象都将占用8字节的倍数空间，而不管是否全部使用。

阵列列表：

ArrayList对象头+大小整数+modCount整数+数组引用+（数组项目头+b*n）+MOD

链接列表：

LinkedList对象标头+大小整数+modCount整数+对标头的引用+对页脚的引用+（节点对象开销+对上一元素的引用+下一元素的参考+对元素的引用）*n）+MOD（节点对象，8）*n+MOD， 8)

我的经验法则是，如果我需要一个集合（即不需要是一个列表），那么如果你事先知道大小，或者可以自信地知道大小，或知道它不会有太大变化，那么就使用ArrayList。如果您需要随机访问（即使用get（index）），请避免LinkedList。基本上，只有当您不需要索引访问并且不知道正在分配的集合的（近似）大小时，才使用LinkedList。此外，如果您要进行大量添加和删除（再次通过Collection接口），则LinkedList可能更可取。

我在这里看到的一个测试只进行一次测试。但我注意到的是，您需要多次运行这些测试，最终它们的时间会收敛。基本上JVM需要预热。对于我的特定用例，我需要向列表中添加/删除项目，该列表将增加到大约500个项目。在我的测试中，LinkedList的发布速度更快，LinkedList约为50000 NS，ArrayList约为90000NS。。。给予或索取。请参见下面的代码。

public static void main(String[] args) {
    List<Long> times = new ArrayList<>();
    for (int i = 0; i < 100; i++) {
        times.add(doIt());
    }
    System.out.println("avg = " + (times.stream().mapToLong(x -> x).average()));
}

static long doIt() {
    long start = System.nanoTime();
    List<Object> list = new LinkedList<>();
    //uncomment line below to test with ArrayList
    //list = new ArrayList<>();
    for (int i = 0; i < 500; i++) {
        list.add(i);
    }

    Iterator it = list.iterator();
    while (it.hasNext()) {
        it.next();
        it.remove();
    }
    long end = System.nanoTime();
    long diff = end - start;
    //uncomment to see the JVM warmup and get faster for the first few iterations
    //System.out.println(diff)
    return diff;
}