对于ArrayList和LinkedList，remove（）和insert（）的运行时效率都为O（n）。然而，线性处理时间背后的原因来自两个非常不同的原因：

在ArrayList中，您可以找到O（1）中的元素，但实际上删除或插入某些元素会使其成为O（n），因为以下所有元素都需要更改。

在LinkedList中，实际到达所需元素需要O（n），因为我们必须从一开始就开始，直到达到所需的索引。实际上，移除或插入是常量，因为我们只需要为remove（）更改1个引用，为insert（）更改2个引用。

插入和删除这两项中的哪一项更快取决于发生的位置。如果我们更接近开始，LinkedList将更快，因为我们必须经过相对较少的元素。如果我们接近末尾，ArrayList将更快，因为我们在恒定的时间内到达那里，只需更改紧随其后的几个剩余元素。如果正好在中间完成，LinkedList将更快速，因为遍历n个元素比移动n个值更快。

好处：虽然无法为ArrayList创建这两个方法O（1），但实际上在LinkedList中有一种方法可以做到这一点。假设我们想在整个列表中删除和插入元素。通常，您可以使用LinkedList从头开始每个元素，我们也可以使用迭代器“保存”当前正在处理的元素。在迭代器的帮助下，当在LinkedList中工作时，remove（）和insert（）的效率为O（1）。使其成为我所知的唯一性能优势，LinkedList总是优于ArrayList。

ArrayList是您想要的。LinkedList几乎总是一个（性能）bug。

为什么LinkedList很糟糕：

它使用了大量小内存对象，因此影响了整个过程的性能。许多小对象不利于缓存位置。任何索引操作都需要遍历，即具有O（n）性能。这在源代码中并不明显，导致算法O（n）比使用ArrayList时慢。获得好的表现是很棘手的。即使big-O性能与ArrayList相同，它也可能会明显变慢。在源代码中看到LinkedList很刺耳，因为它可能是错误的选择。

以下是ArrayList和LinkedList以及CopyOnWrite ArrayList中的Big-O符号：

阵列列表

get                 O(1)
add                 O(1)
contains            O(n)
next                O(1)
remove              O(n)
iterator.remove     O(n)

链表

get                 O(n)
add                 O(1)
contains            O(n)
next                O(1)
remove              O(1)
iterator.remove     O(1)

CopyOnWrite阵列列表

get                 O(1)
add                 O(n)
contains            O(n)
next                O(1)
remove              O(n)
iterator.remove     O(n)

基于这些，您必须决定选择什么。：）

与LinkedList相比，Summary ArrayList和ArrayDeque在更多的用例中更可取。如果您不确定，请从ArrayList开始。

TLDR，在ArrayList中，访问元素需要恒定的时间[O（1）]，添加元素需要O（n）时间[最坏情况]。在LinkedList中，插入元素需要O（n）时间，访问也需要O（n）时间，但LinkedList比ArrayList使用更多内存。

LinkedList和ArrayList是List接口的两种不同实现。LinkedList使用双链接列表实现它。ArrayList通过动态调整数组大小来实现它。

与标准的链表和数组操作一样，不同的方法将有不同的算法运行时。

对于LinkedList＜E＞

get（int index）为O（n）（平均步数为n/4），但当index=0或index=list.size（）-1时为O（1）（在这种情况下，还可以使用getFirst（）和getLast（））。LinkedList的主要优点之一add（int index，E元素）为O（n）（平均步数为n/4），但当index=0或index=list.size（）-1时为O（1）（在这种情况下，还可以使用addFirst（）和addLast（）/add（））。LinkedList的主要优点之一remove（int index）为O（n）（平均步数为n/4），但当index=0或index=list.size（）-1时为O（1）（在这种情况下，还可以使用removeFirst（）和removeLast（））。LinkedList的主要优点之一Iterator.remove（）为O（1）。LinkedList的主要优点之一ListIterator.add（E元素）为O（1）。LinkedList的主要优点之一

注：许多操作平均需要n/4步，在最佳情况下（例如索引=0）需要恒定的步数，在最坏情况下（列表中间）需要n/2步

对于ArrayList＜E＞

get（int索引）为O（1）。ArrayList的主要优势<E>add（E元素）是O（1）摊销，但O（n）最坏情况，因为数组必须调整大小并复制add（int索引，E元素）为O（n）（平均n/2步）remove（int索引）为O（n）（平均n/2步）Iterator.remove（）为O（n）（平均为n/2步）ListIterator.add（E元素）为O（n）（平均n/2步）

注：许多操作平均需要n/2步，在最佳情况下（列表末尾）需要恒定的步数，在最坏情况下（开始列表）需要n步

LinkedList＜E＞允许使用迭代器进行恒定时间的插入或删除，但只能对元素进行顺序访问。换句话说，您可以向前或向后遍历列表，但在列表中找到位置所需的时间与列表的大小成正比。Javadoc表示“索引到列表中的操作将从开始或结束遍历列表，以较近者为准”，因此这些方法平均为O（n）（n/4步），尽管索引=0时为O（1）。

另一方面，ArrayList＜E＞允许快速随机读取访问，因此您可以在恒定时间内获取任何元素。但是，除了末端之外，任何地方的添加或删除都需要将后面的所有元素转换过来，要么打开，要么填补空白。此外，如果添加的元素超过了基础数组的容量，则会分配一个新数组（大小的1.5倍），并将旧数组复制到新数组，因此在最坏的情况下，添加到ArrayList是O（n），但平均来说是常量。

因此，根据您打算执行的操作，您应该相应地选择实现。对这两种列表进行迭代实际上都是同样便宜的。（在ArrayList上迭代在技术上更快，但除非您正在做一些对性能非常敏感的事情，否则不必担心这一点——它们都是常量。）

使用LinkedList的主要好处是重用现有迭代器来插入和删除元素。然后，这些操作可以在O（1）中通过仅本地更改列表来完成。在阵列列表中，需要移动（即复制）阵列的其余部分。另一方面，在LinkedList中查找意味着在最坏情况下遵循O（n）（n/2步）中的链接，而在ArrayList中，所需位置可以通过数学计算并在O（1）中访问。

使用LinkedList的另一个好处是在列表的开头添加或删除，因为这些操作是O（1），而ArrayList是O（n）。请注意，ArrayDeque可能是LinkedList的一个很好的替代方案，用于添加和删除头部，但它不是List。

此外，如果您有大量列表，请记住内存使用情况也不同。LinkedList的每个元素都有更多的开销，因为指向下一个和上一个元素的指针也会被存储。ArrayList没有这个开销。然而，ArrayList占用的内存与为容量分配的内存一样多，而不管是否实际添加了元素。

ArrayList的默认初始容量非常小（Java 1.4-1.8中为10）。但由于底层实现是一个数组，如果添加大量元素，则必须调整数组的大小。为了避免在知道要添加大量元素时调整大小的高昂成本，请使用更高的初始容量构建ArrayList。

如果使用数据结构透视图来理解这两个结构，LinkedList基本上是一个包含头节点的顺序数据结构。Node是两个组件的包装器：一个类型为T的值[通过泛型接受]，另一个对链接到它的Node的引用。因此，我们可以断言它是一个递归数据结构（一个Node包含另一个节点，该节点具有另一个Node等等…）。如上所述，在LinkedList中添加元素需要线性时间。

ArrayList是一个可增长的数组。它就像一个常规数组。在后台，当添加了一个元素，并且ArrayList已经满了容量时，它将创建另一个大小大于先前大小的数组。然后将元素从先前的数组复制到新的数组，并且将要添加的元素也放置在指定的索引处。

ArrayList扩展了AbstractList并实现了List接口。ArrayList是动态数组。可以说，它的创建基本上是为了克服数组的缺点LinkedList类扩展了AbstractSequentialList并实现了List、Deque和Queue接口。表演arraylist.get（）是O（1），而linkedlist.getarraylist.add（）为O（1），linkedlist.add）为0（1）arraylist.contains（）为O（n），linkedlist.contans（）为0（n）arraylist.next（）为O（1），linkedlist.next（）为0（1）arraylist.remove（）是O（n），而linkedlist.remove（）是0（1）在arraylistiterator.remove（）是O（n），而在linkedlist迭代器.remove

让我们将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中，每个索引仅保存实际对象（数据）。

来源