java arraylist无序吗_何时在Java中使用LinkedList over ArrayList？

何时在Java中使用LinkedList over ArrayList？

我一直只是一个人使用：

List names = new ArrayList<>();

我使用接口作为可移植性的类型名称，因此当我问这些问题时，我可以重新编写代码。

何时应该使用ArrayList而不是ArrayList，反之亦然？

30个解决方案

2943 votes

总结ArrayList与ArrayList在更多的用例中比ArrayLists更好。如果你不确定 - 只需从LinkedList开始。

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

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

对于ArrayList

ArrayList是O(n)(平均n / 4步)

ArrayList是O(1)

ArrayList是O(n)(平均n / 4步)，但O(1)时ArrayList＆lt; ---主要受益于ArrayLists

ArrayList是O(n)(平均n / 4步)

ArrayList是O(1)。 ＆lt; ---主要受益于ArrayList

ArrayList是O(1)这是ArrayList的主要好处之一

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

对于ArrayList

ArrayList是O(1)＆lt; ---主要受益于ArrayList

ArrayList是O(1)摊销，但O(n)最坏情况，因为数组必须调整大小并复制

ArrayList是O(n)(平均n / 2步)

ArrayList is O(n) (with n/2 steps on average)

ArrayList is O(n) (with n/2 steps on average)

ArrayList is O(n) (with n/2 steps on average)

注意：许多操作平均需要n / 2步，最好的情况下是常数步(列表末尾)，最坏情况下是n步(列表开头)

ArrayList允许使用迭代器进行常量插入或删除，但只允许顺序访问元素。 换句话说，您可以向前或向后遍历列表，但在列表中查找位置需要的时间与列表的大小成比例。 Javadoc说“索引到列表中的操作将从开头或结尾遍历列表，以较近者为准”，因此这些方法平均为O(n)(n / 4步)，尽管O(1)为ArrayList。

另一方面，ArrayList允许快速随机读取访问，因此您可以在恒定时间内获取任何元素。 但是，除了末端之外的任何地方添加或移除都需要将所有后面的元素移位，以便打开或填补空白。 此外，如果添加的元素多于底层数组的容量，则会分配一个新数组(大小的1.5倍)，并将旧数组复制到新数组，因此添加到ArrayList中的是O(n) 最坏的情况，但平均不变。

因此，根据您打算执行的操作，您应该相应地选择实现。 迭代任何一种List实际上同样便宜。 (迭代ArrayList在技术上更快，但除非你做的事情对性能非常敏感，否则你不应该担心这一点 - 它们都是常量。)

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

当您从列表的头部添加或删除时，会出现使用ArrayList的另一个好处，因为这些操作是O(1)，而对于ArrayList，它们是O(n)。请注意，ArrayLists可能是2137492979047721330的一个很好的替代方案，用于添加 并从头部删除，但它不是List。

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

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

Jonathan Tran answered 2018-12-20T21:48:18Z

551 votes

到目前为止，除了LinkedList比ArrayList“更多”的普遍共识之外，没有人似乎已经解决了这些列表中的每一个的内存占用，所以我做了一些数字处理以准确地证明两个列表占用N个空引用的确切数量。

由于在它们的相对系统上引用是32或64位(即使为空)，我已经包括4组数据32和64位LinkedList和ArrayList。

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

注2 :(感谢BeeOnRope)由于CompressedOops现在默认从JDK6中间开始，因此64位机器的下面的值基本上与它们的32位机器相匹配，除非您特别关闭它。

结果清楚地表明，LinkedList比ArrayList多了很多，尤其是元素数量非常多。 如果记忆是一个因素，请避开LinkedLists。

我使用的公式如下，让我知道如果我做错了什么我会解决它。 对于32或64位系统，'b'为4或8，'n'是元素的数量。 注意mods的原因是因为java中的所有对象将占用8个字节空间的倍数，无论它是否全部使用。

LinkedList：

ArrayList object header + size integer + modCount integer + array reference + (array oject header + b * n) + MOD(array oject, 8) + MOD(ArrayList object, 8) == 8 + 4 + 4 + b + (12 + b * n) + MOD(12 + b * n, 8) + MOD(8 + 4 + 4 + b + (12 + b * n) + MOD(12 + b * n, 8), 8)

LinkedList:

LinkedList object header + size integer + modCount integer + reference to header + reference to footer + (node object overhead + reference to previous element + reference to next element + reference to element) * n) + MOD(node object, 8) * n + MOD(LinkedList object, 8) == 8 + 4 + 4 + 2 * b + (8 + 3 * b) * n + MOD(8 + 3 * b, 8) * n + MOD(8 + 4 + 4 + 2 * b + (8 + 3 * b) * n + MOD(8 + 3 * b, 8) * n, 8)

Numeron answered 2018-12-20T21:50:07Z

198 votes

LinkedList是你想要的。 LinkedList几乎总是一个(性能)错误。

为什么LinkedList很糟糕：

它使用大量小内存对象，因此会影响整个过程的性能。

很多小对象都不利于缓存局部性。

任何索引操作都需要遍历，即具有O(n)性能。 这在源代码中并不明显，导致算法O(n)比使用LinkedList时慢。

获得良好的表现很棘手。

即使大O的性能与LinkedList相同，但无论如何它可能会明显变慢。

在源代码中看到LinkedList令人不快，因为它可能是错误的选择。

Tom Hawtin - tackline answered 2018-12-20T21:50:58Z

130 votes

作为一个在非常大规模的SOA Web服务上进行操作性能工程大约十年的人，我更喜欢LinkedList相对于ArrayList的行为。 虽然LinkedList的稳态吞吐量更差，因此可能导致购买更多硬件 - ArrayList在压力下的行为可能导致集群中的应用程序在几乎同步的情况下扩展其阵列，并且对于大型阵列可能导致缺乏响应性 在应用程序和停电，而在压力下，这是灾难性的行为。

类似地，您可以从默认吞吐量终身垃圾收集器中获得更好的应用程序吞吐量，但是一旦获得具有10GB堆的Java应用程序，您可以在完整GC期间锁定应用程序25秒，这会导致SOA应用程序超时和失败 并且如果太频繁发生，则会破坏您的SLA。 即使CMS收集器占用更多资源并且无法实现相同的原始吞吐量，但它是一个更好的选择，因为它具有更可预测和更小的延迟。

如果性能的全部意思是吞吐量，并且您可以忽略延迟，那么ArrayList只是性能的更好选择。 根据我的工作经验，我不能忽视最坏情况的延迟。

lamont answered 2018-12-20T21:51:29Z

113 votes

Algorithm ArrayList LinkedList

seek front O(1) O(1)

seek back O(1) O(1)

seek to index O(1) O(N)

insert at front O(N) O(1)

insert at back O(1) O(1)

insert after an item O(N) O(1)

算法：Big-Oh表示法

ArrayLists适合一次写入多次读取或appender，但在前面或中间添加/删除时效果不佳。

Michael Munsey answered 2018-12-20T21:51:53Z

95 votes

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

在性能方面，LinkedList几乎总是错误的选择。 有一些非常具体的算法需要一个LinkedList，但那些非常非常罕见，并且算法通常特别依赖于LinkedList能够相对快速地插入和删除列表中间的元素，一旦你在那里导航 使用ListIterator。

有一个常见的用例，其中LinkedList优于ArrayList：队列的那个。 但是，如果您的目标是性能，而不是LinkedList，您还应考虑使用ArrayBlockingQueue(如果您可以提前确定队列大小的上限，并且可以预先分配所有内存)，或者此CircularArrayList实现。 (是的，它是从2001年开始的，所以你需要对它进行一般化，但我的性能比率与刚刚在最近的JVM中引用的内容相当)

Daniel Martin answered 2018-12-20T21:52:23Z

52 votes

这是一个效率问题。 LinkedList快速添加和删除元素，但访问特定元素的速度很慢。 ArrayList访问特定元素的速度很快，但添加到任何一端都很慢，特别是在中间删除速度很慢。

Array vs ArrayList vs LinkedList vs Vector更深入，也是如此链接列表。

dgtized answered 2018-12-20T21:52:48Z

50 votes

正确或不正确：请在本地执行测试并自行决定！

编辑/删除在ArrayList比Array更快。

ArrayList，由Array支持，需要倍大，在大批量应用中更糟糕。

下面是每个操作的单位测试结果。时间以纳秒为单位。

Operation ArrayList LinkedList

AddAll (Insert) 101,16719 2623,29291

Add (Insert-Sequentially) 152,46840 966,62216

Add (insert-randomly) 36527 29193

remove (Delete) 20,56,9095 20,45,4904

contains (Search) 186,15,704 189,64,981

这是代码：

import org.junit.Assert;

import org.junit.Test;

import java.util.*;

public class ArrayListVsLinkedList {

private static final int MAX = 500000;

String[] strings = maxArray();

// ADD ALL

@Test

public void arrayListAddAll() {

Watch watch = new Watch();

List stringList = Arrays.asList(strings);

List arrayList = new ArrayList(MAX);

watch.start();

arrayList.addAll(stringList);

watch.totalTime("Array List addAll() = ");//101,16719 Nanoseconds

}

@Test

public void linkedListAddAll() throws Exception {

Watch watch = new Watch();

List stringList = Arrays.asList(strings);

watch.start();

List linkedList = new LinkedList();

linkedList.addAll(stringList);

watch.totalTime("Linked List addAll() = "); //2623,29291 Nanoseconds

}

//Note: ArrayList is 26 time faster here than LinkedList for addAll()

/ INSERT /

@Test

public void arrayListAdd() {

Watch watch = new Watch();

List arrayList = new ArrayList(MAX);

watch.start();

for (String string : strings)

arrayList.add(string);

watch.totalTime("Array List add() = ");//152,46840 Nanoseconds

}

@Test

public void linkedListAdd() {

Watch watch = new Watch();

List linkedList = new LinkedList();

watch.start();

for (String string : strings)

linkedList.add(string);

watch.totalTime("Linked List add() = "); //966,62216 Nanoseconds

}

//Note: ArrayList is 9 times faster than LinkedList for add sequentially

/// INSERT IN BETWEEN ///

@Test

public void arrayListInsertOne() {

Watch watch = new Watch();

List stringList = Arrays.asList(strings);

List arrayList = new ArrayList(MAX + MAX / 10);

arrayList.addAll(stringList);

String insertString0 = getString(true, MAX / 2 + 10);

String insertString1 = getString(true, MAX / 2 + 20);

String insertString2 = getString(true, MAX / 2 + 30);

String insertString3 = getString(true, MAX / 2 + 40);

watch.start();

arrayList.add(insertString0);

arrayList.add(insertString1);

arrayList.add(insertString2);

arrayList.add(insertString3);

watch.totalTime("Array List add() = ");//36527

}

@Test

public void linkedListInsertOne() {

Watch watch = new Watch();

List stringList = Arrays.asList(strings);

List linkedList = new LinkedList();

linkedList.addAll(stringList);

String insertString0 = getString(true, MAX / 2 + 10);

String insertString1 = getString(true, MAX / 2 + 20);

String insertString2 = getString(true, MAX / 2 + 30);

String insertString3 = getString(true, MAX / 2 + 40);

watch.start();

linkedList.add(insertString0);

linkedList.add(insertString1);

linkedList.add(insertString2);

linkedList.add(insertString3);

watch.totalTime("Linked List add = ");//29193

}

//Note: LinkedList is 3000 nanosecond faster than ArrayList for insert randomly.

// DELETE //

@Test

public void arrayListRemove() throws Exception {

Watch watch = new Watch();

List stringList = Arrays.asList(strings);

List arrayList = new ArrayList(MAX);

arrayList.addAll(stringList);

String searchString0 = getString(true, MAX / 2 + 10);

String searchString1 = getString(true, MAX / 2 + 20);

watch.start();

arrayList.remove(searchString0);

arrayList.remove(searchString1);

watch.totalTime("Array List remove() = ");//20,56,9095 Nanoseconds

}

@Test

public void linkedListRemove() throws Exception {

Watch watch = new Watch();

List linkedList = new LinkedList();

linkedList.addAll(Arrays.asList(strings));

String searchString0 = getString(true, MAX / 2 + 10);

String searchString1 = getString(true, MAX / 2 + 20);

watch.start();

linkedList.remove(searchString0);

linkedList.remove(searchString1);

watch.totalTime("Linked List remove = ");//20,45,4904 Nanoseconds

}

//Note: LinkedList is 10 millisecond faster than ArrayList while removing item.

/ SEARCH ///

@Test

public void arrayListSearch() throws Exception {

Watch watch = new Watch();

List stringList = Arrays.asList(strings);

List arrayList = new ArrayList(MAX);

arrayList.addAll(stringList);

String searchString0 = getString(true, MAX / 2 + 10);

String searchString1 = getString(true, MAX / 2 + 20);

watch.start();

arrayList.contains(searchString0);

arrayList.contains(searchString1);

watch.totalTime("Array List addAll() time = ");//186,15,704

}

@Test

public void linkedListSearch() throws Exception {

Watch watch = new Watch();

List linkedList = new LinkedList();

linkedList.addAll(Arrays.asList(strings));

String searchString0 = getString(true, MAX / 2 + 10);

String searchString1 = getString(true, MAX / 2 + 20);

watch.start();

linkedList.contains(searchString0);

linkedList.contains(searchString1);

watch.totalTime("Linked List addAll() time = ");//189,64,981

}

//Note: Linked List is 500 Milliseconds faster than ArrayList

class Watch {

private long startTime;

private long endTime;

public void start() {

startTime = System.nanoTime();

}

private void stop() {

endTime = System.nanoTime();

}

public void totalTime(String s) {

stop();

System.out.println(s + (endTime - startTime));

}

}

private String[] maxArray() {

String[] strings = new String[MAX];

Boolean result = Boolean.TRUE;

for (int i = 0; i < MAX; i++) {

strings[i] = getString(result, i);

result = !result;

}

return strings;

}

private String getString(Boolean result, int i) {

return String.valueOf(result) + i + String.valueOf(!result);

}

}

Ash answered 2018-12-20T21:53:25Z

41 votes

add本质上是一个数组。 remove实现为双链表。

add非常清楚。 O(1)for remove，因为ArrayList允许使用索引进行随机访问。 O(n)为LinkedList，因为它需要先找到索引。 注意：有不同版本的add和remove。

add添加和删除速度更快，但获取速度更慢。 简而言之，如果出现以下情况，应首选remove：

没有大量的随机访问元素

有大量的添加/删除操作

=== ArrayList ===

添加(E e)在ArrayList的末尾添加

需要内存调整成本。

O(n)最差，O(1)摊销

add(int index，E element)添加到特定的索引位置

要求转移＆amp; 可能的内存调整成本

上)

remove(int index)删除指定的元素

要求转移＆amp; 可能的内存调整成本

上)

删除(对象o)从此列表中删除指定元素的第一个匹配项

需要首先搜索元素，然后移动＆amp; 可能的内存调整成本

上)

=== LinkedList ===

添加(E e)

添加到列表的末尾

O(1)

add(int index，E element)

插入指定位置

需要先找到位置

上)

去掉()删除列表的第一个元素

O(1)

remove(int index)删除具有指定索引的元素

需要先找到元素

上)

删除(对象o)删除指定元素的第一个匹配项

需要先找到元素

上)

这是programcreek.com的图(add和remove是第一种类型，即在列表末尾添加一个元素并删除列表中指定位置的元素。)：

Ryan answered 2018-12-20T21:56:45Z

32 votes

1)搜索：与LinkedList搜索操作相比，ArrayList搜索操作非常快。 ArrayList中的get(int index)给出O(1)的性能，而LinkedList性能为O(n)。

原因：ArrayList为其元素维护一个基于索引的系统，因为它隐式使用数组数据结构，这使得搜索列表中的元素更快。 另一方面，LinkedList实现了一个双向链表，需要遍历所有元素来搜索元素。

2)删除：LinkedList删除操作给出O(1)性能，而ArrayList给出可变性能：在最坏情况下(在删除第一个元素时为O(n))和在最佳情况下为O(1)(在删除最后一个元素时)。

结论：与ArrayList相比，LinkedList元素删除更快。

原因：每个LinkedList的元素都维护两个指针(地址)，指向列表中的两个邻居元素。 因此，移除仅需要改变将要移除的节点的两个相邻节点(元素)中的指针位置。 在In ArrayList中，需要移动所有元素以填充由remove元素创建的空间。

3)插入性能：LinkedList add方法给出O(1)性能，而ArrayList在最坏情况下给出O(n)。 原因与删除时解释的相同。

4)内存开销：ArrayList维护索引和元素数据，而LinkedList维护元素数据和相邻节点的两个指针，因此LinkedList中的内存消耗相对较高。

这些类之间几乎没有相似之处，如下所示：

ArrayList和LinkedList都是List接口的实现。它们都维护元素的插入顺序，这意味着在显示ArrayList和LinkedList元素时，结果集将具有将元素插入List的相同顺序。这两个类都是非同步的，可以使用Collections.synchronizedList方法显式同步。这些类返回的迭代器和listIterator是快速失败的(如果在创建迭代器之后的任何时候对列表进行结构修改，除了通过迭代器自己的remove或add方法之外，迭代器将抛出ConcurrentModificationException)。

何时使用LinkedList以及何时使用ArrayList？

1)如上所述，与ArrayList(O(n))相比，insertList和remove操作在LinkedList中提供了良好的性能(O(1))。 因此，如果在应用程序中需要频繁添加和删除，则LinkedList是最佳选择。

2)搜索(get方法)操作在ArrayList(O(1))中快速但在LinkedList(O(n))中没有，因此如果添加和删除操作较少且搜索操作要求较多，则ArrayList将是您最好的选择。

NoNaMe answered 2018-12-20T21:58:54Z

31 votes

ArrayList是随机可访问的，而LinkedList是非常便宜的扩展和删除元素。 在大多数情况下，ArrayList没问题。

除非您创建了大型列表并测量了瓶颈，否则您可能永远不必担心这些差异。

Dustin answered 2018-12-20T21:59:18Z

28 votes

LinkedList的作者Joshua Bloch：

有没有人真正使用LinkedList？ 我写了它，我从来没用过它。

链接：[https://twitter.com/joshbloch/status/583813919019573248]

我很抱歉答案不像其他答案那样提供信息，但我认为这将是最有趣和不言自明的。

Ruslan answered 2018-12-20T21:59:52Z

19 votes

如果您的代码有add(0)和remove(0)，请使用LinkedList，它更漂亮addFirst()和removeFirst()方法。 否则，请使用ArrayList。

当然，Guava的ImmutableList是你最好的朋友。

Jesse Wilson answered 2018-12-20T22:00:16Z

19 votes

我知道这是一个老帖子，但我老实说不敢相信没人提到LinkedList实现Deque.只需看看Deque(和Queue)中的方法; 如果你想要公平的比较，尝试运行LinkedList对ArrayDeque并进行功能比较。

Ajax answered 2018-12-20T22:00:37Z

16 votes

以下是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)

写入时复制-的ArrayList

get O(1)

add O(n)

contains O(n)

next O(1)

remove O(n)

iterator.remove O(n)

基于这些，你必须决定选择什么。:)

Rajith Delantha answered 2018-12-20T22:01:14Z

12 votes

让我们比较LinkedList和ArrayList w.r.t. 以下参数：

1.实施

ArrayList是列表接口的可调整大小的数组实现，而

LinkedList是列表界面的双向链表实现。

2.表现

get(int index)或搜索操作

ArrayList get(int index)操作以恒定时间运行，即O(1)while

LinkedList get(int index)操作运行时间为O(n)。

ArrayList比LinkedList更快的原因是ArrayList使用基于索引的系统作为其元素，因为它在内部使用数组数据结构，另一方面，

LinkedList不为其元素提供基于索引的访问，因为它从开头或结尾(以较近者为准)进行迭代，以检索指定元素索引处的节点。

insert()或add(Object)操作

与ArrayList相比，Linked List中的插入通常很快。 在链接列表中添加或插入是O(1)操作。

在ArrayList中，如果数组是完整的，即最坏的情况，则需要额外调整数组大小和将元素复制到新数组的成本，这使得在ArrayList O(n)中添加运算的运行时，否则它是O(1)。

remove(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()while反向迭代

ArrayList中没有descendingIterator()，所以我们需要编写自己的代码来反向迭代ArrayList。

4.初始容量

如果构造函数没有重载，那么ArrayList会创建一个初始容量为10的空列表

LinkedList仅构造没有任何初始容量的空列表。

5.内存开销

与ArrayList相比，LinkedList中的内存开销更多，因为LinkedList中的节点需要维护下一个节点和上一个节点的地址。 而

在ArrayList中，每个索引只保存实际对象(数据)。

资源

Abhijeet Ashok Muneshwar answered 2018-12-20T22:11:14Z

11 votes

除了上面的其他好的参数，你应该注意ArrayList实现RandomAccess接口，而LinkedList实现Queue。

因此，他们以某种方式解决了稍微不同的问题，效率和行为的差异(参见他们的方法列表)。

PhiLho answered 2018-12-20T22:11:39Z

8 votes

请参阅Java教程 - 列表实现。

chharvey answered 2018-12-20T22:11:58Z

7 votes

数组列表本质上是一个数组，其中包含添加项等的方法(您应该使用通用列表)。 它是可以通过索引器访问的项目集合(例如[0])。 它意味着从一个项目到下一个项目的进展。

链表指定从一个项目到下一个项目的进展(项目a - ＆gt;项目b)。 您可以使用数组列表获得相同的效果，但链接列表绝对说明应该跟随前一个项目。

kemiller2002 answered 2018-12-20T22:12:23Z

7 votes

这取决于您将在列表上执行哪些操作。

ArrayList访问索引值的速度更快。 插入或删除对象时要糟糕得多。

要了解更多信息，请阅读任何讨论数组和链接列表之间差异的文章。

Matthew Schinckel answered 2018-12-20T22:12:52Z

6 votes

我已经阅读了回复，但有一种情况我总是在ArrayList上使用LinkedList，我想分享以听取意见：

每次我有一个返回从DB获得的数据列表的方法时，我总是使用LinkedList。

我的理由是，因为不可能确切地知道我得到了多少结果，所以不会浪费内存(如ArrayList中容量和实际元素数量之间的差异)，并且没有浪费时间试图 复制容量。

至于ArrayList，我同意至少你应该总是使用具有初始容量的构造函数，以尽可能地减少数组的重复。

gaijinco answered 2018-12-20T22:13:26Z

6 votes

链表的一个重要特征(我在另一个答案中没有读到)是两个列表的串联。 对于数组，这是O(n)(+一些重新分配的开销)，链接列表只有O(1)或O(2);-)

重要提示：对于Java，它的LinkedList这不是真的！ 请参阅Java中的链表有快速连接方法吗？

Karussell answered 2018-12-20T22:13:51Z

6 votes

ArrayList中的操作get(i)比LinkedList快，因为：

ArrayList：List接口的可调整大小的数组实现

LinkedList：List和Deque接口的双链表实现

索引到列表中的操作将从开头或结尾遍历列表，以较接近指定索引为准。

Amitābha answered 2018-12-20T22:14:24Z

5 votes

iterator和ArrayList两者都实现了LinkedList，它们的方法和结果几乎完全相同。 然而，它们之间几乎没有差异，这取决于要求，使一个优于另一个。

ArrayList与LinkedList

1)iterator ArrayList与LinkedList搜索操作相比，搜索操作非常快。 ArrayList在O(n)中给出了O(1)的性能，而LinkedList的性能是O(n)。

iterator ArrayList为其元素维护基于索引的系统，因为它隐式使用数组数据结构，这使得搜索列表中的元素更快。 在另一方面，LinkedList实现双向链表，其需要遍历遍历所有元素以搜索元素。

2)iterator ArrayList删除操作给出LinkedList性能，而ArrayList给出可变性能：O(n)在最坏的情况下(同时删除第一个元素)和O(1)在最好的情况下(删除最后一个元素)。

结论：与之相比，LinkedList元素删除更快   数组列表。

原因：LinkedList的每个元素都维护着两个指针(地址)，这些指针指向列表中的两个邻居元素。 因此，移除仅需要改变将要移除的节点的两个相邻节点(元素)中的指针位置。 在In ArrayList中，需要移动所有元素以填充由remove元素创建的空间。

3)iterator ArrayList add方法给出LinkedList性能，而ArrayList给出O(n)最坏情况。 原因与删除时解释的相同。

4)iterator ArrayList维护索引和元素数据，而LinkedList维护元素数据和两个邻居节点指针

因此，LinkedList中的内存消耗相对较高。

这些类之间几乎没有相似之处，如下所示：

ArrayList和LinkedList都是List接口的实现。

它们都维护元素的插入顺序，这意味着在显示ArrayList和LinkedList元素时，结果集将具有将元素插入List的相同顺序。

这两个类都是非同步的，可以使用Collections.synchronizedList方法显式同步。

这些类返回的iterator和get method是Arraylist (O(1))(如果在创建迭代器之后的任何时候对列表进行结构修改，除了通过LinkedList (O(n))自己的删除或添加方法之外，迭代器将为throw一个ConcurrentModificationException)。

何时使用LinkedList以及何时使用ArrayList？

如上所述，与LinkedList (O(n))相比，插入和移除操作在Arraylist (O(1))中提供了良好的性能get method。因此，如果在应用程序中需要频繁添加和删除，则LinkedList是最佳选择。

搜索(get method)的运行快速，在Arraylist (O(1))，但没有在LinkedList (O(n))因此，如果添加和删除操作较少以及搜索操作要求较多，则ArrayList将是您最好的选择。

Real73 answered 2018-12-20T22:16:13Z

5 votes

ArrayList和LinkedList各有利弊。

与使用指向下一个节点的指针的LinkedList相比，ArrayList使用连续的内存地址。 因此，当您想要查找ArrayList中的元素比使用LinkedList进行n次迭代更快时。

另一方面，LinkedList中的插入和删除更容易，因为您只需更改指针，而ArrayList意味着使用shift操作进行任何插入或删除。

如果您的应用程序中有频繁的检索操作，请使用ArrayList。 如果频繁插入和删除，请使用LinkedList。

Nesan Mano answered 2018-12-20T22:16:46Z

5 votes

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

理论上，Linked List对于ArrayList有一个O(1)

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

实践是非常不同的，因为LinkedList是Cache Hostile Data结构。 从性能POV - 在极少数情况下，ArrayList可能比缓存友好的Vector表现更好。

以下是在随机位置插入元素的基准测试结果。 正如您所看到的 - 数组列表如果效率更高，尽管理论上列表中间的每个插入都需要“移动”数组中较晚的元素(较低的值更好)：

使用更新一代的硬件(更大，更高效的缓存) - 结果更具决定性：

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

这有两个主要原因：

主要是 - ArrayList的节点随机分布在内存中。 RAM(“随机存取存储器”)实际上并不是随机的，需要将存储器块提取到高速缓存。 这种操作需要时间，并且当这种提取经常发生时 - 高速缓存中的存储页面需要一直被替换 - ＆gt; 缓存未命中 - ＆gt; 缓存效率不高。Vector元素存储在连续内存中 - 这正是现代CPU架构所优化的内容。

辅助ArrayList需要保持后退/前进指针，这意味着与Vector相比，每个存储器的内存消耗量是3倍。

DynamicIntArray，顺便说一句，是一个自定义的ArrayList实现，持有ArrayList(原始类型)而不是对象 - 因此所有数据都是相邻存储的 - 因此效率更高。

要记住的关键要素是获取内存块的成本比访问单个内存单元的成本更重要。 这就是为什么读取器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

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

为了更清楚地说明这一点，请检查在列表开头添加元素的基准。 这是一个用例，在理论上，ArrayList应该真正发光，而Vector应该会出现糟糕甚至更糟糕的结果：

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

复制顺序大量内存是由现代CPU优化的操作 - 改变理论并实际制作，再次，ArrayList/Vector更高效

致谢：此处发布的所有基准测试均由KjellHedström创建。 他的博客上可以找到更多数据

Lior Bar-On answered 2018-12-20T22:18:20Z

2 votes

1)基础数据结构

ArrayList和LinkedList之间的第一个区别在于ArrayList由Array支持，而LinkedList由LinkedList支持。 这将导致性能的进一步差异。

2)LinkedList实现了Deque

ArrayList和LinkedList之间的另一个区别是，除了List接口之外，LinkedList还实现了Deque接口，它为add()和poll()以及其他几个Deque函数提供先进先出操作。 3)在ArrayList中添加元素在ArrayList中添加元素是O(1)操作，如果它不触发Array的重新大小，在这种情况下它变为O(log(n))，另一方面，添加元素 LinkedList是O(1)操作，因为它不需要任何导航。

4)从位置移除元素

为了从特定索引中删除元素，例如 通过调用remove(index)，ArrayList执行复制操作，使其接近O(n)，而LinkedList需要遍历到该点，这也使其成为O(n / 2)，因为它可以基于接近度从任一方向遍历。

5)迭代ArrayList或LinkedList

迭代是LinkedList和ArrayList的O(n)操作，其中n是元素的数量。

6)从位置检索元素

get(index)操作在ArrayList中是O(1)，而在LinkedList中是O(n / 2)，因为它需要遍历到该条目。 虽然，在Big O表示法O(n / 2)只是O(n)，因为我们忽略那里的常数。

7)记忆

LinkedList使用包装器对象Entry，它是一个静态嵌套类，用于存储数据和下一个和上一个节点，而ArrayList只是将数据存储在Array中。

因此，对于ArrayList而言，内存需求似乎少于LinkedList，除非Array在将内容从一个Array复制到另一个Array时执行重新大小操作。

如果Array足够大，那么此时可能需要大量内存并触发垃圾收集，这会减慢响应时间。

从ArrayList与LinkedList之间的所有上述差异来看，几乎在所有情况下，看起来ArrayList是比LinkedList更好的选择，除非你执行频繁的add()操作而不是remove()或get()。

修改链表比ArrayList更容易，特别是如果要从开始或结束添加或删除元素，因为链表在内部保留对这些位置的引用，并且可以在O(1)时间内访问它们。

换句话说，您不需要遍历链表以到达要添加元素的位置，在这种情况下，添加变为O(n)操作。 例如，在链接列表的中间插入或删除元素。

在我看来，对于Java中的大多数实际用途，使用LinkedList而不是LinkedList。

Anjali Suman answered 2018-12-20T22:19:59Z

1 votes

remove()和insert()对于ArrayLists和LinkedLists都具有O(n)的运行时效率。 然而，线性处理时间背后的原因有两个非常不同的原因：

在ArrayList中，您可以访问O(1)中的元素，但实际上删除或插入某些内容会使其成为O(n)，因为需要更改以下所有元素。

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

插入和移除两者中哪一个更快取决于它发生的位置。 如果我们离开头更近，LinkedList会更快，因为我们必须经历相对较少的元素。 如果我们接近结束，ArrayList将更快，因为我们在恒定时间到达那里并且只需要改变其后的几个剩余元素。 当精确地在中间完成时，LinkedList将更快，因为遍历n个元素比移动n个值更快。

额外：虽然无法为ArrayList创建这两个方法O(1)，但实际上有一种方法可以在LinkedLists中执行此操作。 假设我们想要在整个List中删除并插入元素。 通常，您将从一开始就使用LinkedList开始每个元素，我们也可以“保存”我们正在使用Iterator处理的当前元素。 在Iterator的帮助下，当在LinkedList中工作时，我们获得了remove()和insert()的O(1)效率。 使它成为唯一的性能优势我知道LinkedList总是比ArrayList更好。

pietz answered 2018-12-20T22:20:39Z

0 votes

ArrayList扩展了AbstractList并实现了List接口。 ArrayList是动态数组。

可以说它基本上是为克服阵列的缺点而创建的

LinkedList类扩展了AbstractSequentialList并实现了List，Deque和Queue接口。

性能

arraylist.get()是O(1)而linkedlist.get()是O(n)

arraylist.add()是O(1)和linkedlist.add()是0(1)

arraylist.contains()是O(n)和linkedlist.contains()是O(n)

arraylist.next()是O(1)和linkedlist.next()是O(1)

arraylist.remove()是O(n)而linkedlist.remove()是O(1)

在arraylist

iterator.remove()是O(n)

而在链表中

iterator.remove()is O(1)

Randhawa answered 2018-12-20T22:21:52Z

0 votes

我在这里看到的其中一项测试只进行了一次测试。 但我注意到你需要多次运行这些测试，最终它们的时间会收敛。 基本上JVM需要预热。 对于我的特定用例，我需要添加/删除项目到最后增加到约500项。 在我的测试LinkedList出来更快，链接LinkedList约50,000 50,000 NS和ArrayList约90,000 NS ...给予或采取。 请参阅下面的代码。

public static void main(String[] args) {

List 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 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;

}

Jose Martinez answered 2018-12-20T22:22:13Z