blocks|key|1850350|text|这是一个效率问题。LinkedList用于添加和删除元素的速度很快，但访问特定元素的速度很慢。ArrayList访问特定元素的速度很快，但添加到两端的速度可能会很慢，特别是在中间删除元素的速度会更慢。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1850351|与Linked+List一样，Array+vs+ArrayList+vs+LinkedList+vs+Vector也更加深入。|1850352|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Linked_list|1|https://web.archive.org/web/20090204031044/http://www.javafaq.nu/java-article1111.html^0|9|A|1B|9|0|1|B|0|F|16|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|H|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

It's an efficiency question. <code>LinkedList</code> is fast for adding and deleting elements, but slow to access a specific element. <code>ArrayList</code> is fast for accessing a specific element but can be slow to add to either end, and especially slow to delete in the middle.

<a href="https://web.archive.org/web/20090204031044/http://www.javafaq.nu/java-article1111.html" rel="noreferrer">Array vs ArrayList vs LinkedList vs Vector</a> goes more in depth, as does 
<a href="http://en.wikipedia.org/wiki/Linked_list" rel="noreferrer">Linked List</a>.

blocks|key|1850426|text|ArrayList是可随机访问的，而LinkedList扩展和删除元素的成本非常低。在大多数情况下，ArrayList都很好。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1850427|除非您创建了大型列表并测量了瓶颈，否则您可能永远不需要担心差异。|1850428|entityMap^0|0|9|I|A|1E|9|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

<code>ArrayList</code> is randomly accessible, while <code>LinkedList</code> is really cheap to expand and remove elements from. For most cases, <code>ArrayList</code> is fine.

Unless you've created large lists and measured a bottleneck, you'll probably never need to worry about the difference.

blocks|key|2064500|text|这取决于你在列表中要做的更多操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2064501|ArrayList访问索引值的速度更快。在插入或删除对象时，情况会更糟。|offset|length|style|CODE|2064502|要了解更多信息，请阅读任何讨论数组和链表之间差异的文章。|2064503|entityMap^0|0|0|9|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

It depends upon what operations you will be doing more on the List.

<code>ArrayList</code> is faster to access an indexed value. It is much worse when inserting or deleting objects.

To find out more, read any article that talks about the difference between arrays and linked lists.

blocks|key|2064567|text|除了上面的其他好论点之外，您还应该注意到ArrayList实现了RandomAccess接口，而LinkedList实现了Queue。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2064568|因此，它们以某种方式解决了略微不同的问题，效率和行为也有所不同(参见他们的方法列表)。|2064569|entityMap^0|K|9|W|C|1C|A|1P|5|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

In addition to the other good arguments above, you should notice <code>ArrayList</code> implements <code>RandomAccess</code> interface, while <code>LinkedList</code> implements <code>Queue</code>.

So, somehow they address slightly different problems, with difference of efficiency and behavior (see their list of methods).

blocks|key|2064597|text|如果您的代码有add(0)和remove(0)，请使用LinkedList，它是更漂亮的addFirst()和removeFirst()方法。否则，请使用ArrayList。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2064598|当然，Guava的ImmutableList是你最好的朋友。|2064599|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/google/guava|1|https://google.github.io/guava/releases/21.0/api/docs/com/google/common/collect/ImmutableList.html^0|7|6|E|9|R|A|18|A|1J|D|25|9|0|3|5|0|9|D|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@$9|15|A|16|1|17]|$9|18|A|19|1|1A]]|E|$]]|$1|H|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

If your code has <code>add(0)</code> and <code>remove(0)</code>, use a <code>LinkedList</code> and it's prettier <code>addFirst()</code> and <code>removeFirst()</code> methods. Otherwise, use <code>ArrayList</code>.

And of course, <a href="https://github.com/google/guava" rel="noreferrer">Guava</a>'s <a href="https://google.github.io/guava/releases/21.0/api/docs/com/google/common/collect/ImmutableList.html" rel="noreferrer">ImmutableList</a> is your best friend.

blocks|key|1850604|text|是的，我知道，这是一个古老的问题，但我会加入我的观点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1850605|从性能上讲，LinkedList几乎总是错误的选择。有一些非常特定的算法需要LinkedList，但这些算法非常非常罕见，而且算法通常依赖于LinkedList在列表中间相对快速地插入和删除元素的能力，一旦您使用ListIterator导航到列表中间。|1850606|有一种常见的LinkedList优于ArrayList的用例:队列。然而，如果您的目标是性能，而不是LinkedList，那么您还应该考虑使用ArrayBlockingQueue+(如果您可以提前确定队列大小的上限，并且能够预先分配所有内存)，或者使用这个CircularArrayList+implementation。(是的，它来自2001年，所以您需要对其进行泛化，但我得到的性能比率与刚刚在文章中引用的最近的JVM中的性能比率相当)|offset|length|1850607|entityMap|0|LINK|mutability|MUTABLE|url|http://www.javaspecialists.eu/archive/Issue027.html^0|0|0|3K|W|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

Yeah, I know, this is an ancient question, but I'll throw in my two cents:

LinkedList is almost always the wrong choice, performance-wise. There are some very specific algorithms where a LinkedList is called for, but those are very, very rare and the algorithm will usually specifically depend on LinkedList's ability to insert and delete elements in the middle of the list relatively quickly, once you've navigated there with a ListIterator.

There is one common use case in which LinkedList outperforms ArrayList: that of a queue. However, if your goal is performance, instead of LinkedList you should also consider using an ArrayBlockingQueue (if you can determine an upper bound on your queue size ahead of time, and can afford to allocate all the memory up front), or this <a href="http://www.javaspecialists.eu/archive/Issue027.html" rel="noreferrer">CircularArrayList implementation</a>. (Yes, it's from 2001, so you'll need to generify it, but I got comparable performance ratios to what's quoted in the article just now in a recent JVM)

blocks|key|1850624|text|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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1850625|Algorithms:+Big-Oh+Notation+(已存档)|unstyled|offset|length|1850626|ArrayLists适用于一次写入、多次读取或附加，但不适合从前面或中间添加/删除。|1850627|entityMap|0|LINK|mutability|MUTABLE|url|https://web.archive.org/web/20180729155145/http://leepoint.net/algorithms/big-oh/bigoh.html^0|0|0|R|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@$G|U|H|V|1|W]]|A|$]]|$1|I|3|J|5|F|7|X|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<pre><code>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)
</code></pre>
<a href="https://web.archive.org/web/20180729155145/http://leepoint.net/algorithms/big-oh/bigoh.html" rel="noreferrer">Algorithms: Big-Oh Notation</a> (archived)
ArrayLists are good for write-once-read-many or appenders, but bad at add/remove from the front or middle.

blocks|key|1851034|text|它意味着从一个项目到下一个项目的过程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1851035|链表指定从一项到下一项(项a+->项b)的级数。你可以用数组列表得到同样的效果，但链表绝对说明了前一项之后应该是哪一项。|1851036|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

An array list is essentially an array with methods to add items etc. (and you should use a generic list instead). It is a collection of items which can be accessed through an indexer (for example [0]). It implies a progression from one item to the next.

A linked list specifies a progression from one item to the next (Item a -> item b). You can get the same effect with an array list, but a linked list absolutely says what item is supposed to follow the previous one.

blocks|key|2065240|text|作为一个在超大规模scale服务上做了大约十年操作性能工程的人，我更喜欢LinkedList而不是ArrayList的行为。虽然LinkedList的稳态吞吐量更差，因此可能会导致购买更多的硬件--+ArrayList在压力下的行为可能会导致集群中的应用程序以接近同步的方式扩展其阵列，并且对于较大的阵列大小，可能会导致应用程序在承受压力时缺乏响应能力和宕机，这是灾难性的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2065241|类似地，您可以从默认吞吐量租期垃圾收集器获得更好的应用程序吞吐量，但是一旦您获得具有10+if堆的java应用程序，您可能会在整个GC期间锁定应用程序25秒，这会导致SOA应用程序超时和失败，如果它发生得太频繁，还会破坏您的SOA。尽管CMS收集器需要更多的资源，并且没有达到相同的原始吞吐量，但它是一个更好的选择，因为它具有更多的可预测性和更小的延迟。|2065242|如果您所说的性能只是吞吐量，而您可以忽略延迟，那么ArrayList才是更好的性能选择。根据我在工作中的经验，我不能忽略最坏情况下的延迟。|2065243|更新(2021年8月27日--+10年后)：这个答案(我历史上最受欢迎的答案也是如此)很可能是错误的(原因在下面的评论中列出)。我想补充的是，ArrayList将优化对内存的顺序读取，并最大限度地减少高速缓存线和TLB未命中等。考虑到硬件趋势，这个答案也可能随着时间的推移而变得更糟。LinkedList可能有意义的唯一情况是，你有数千个列表，其中任何一个都可能增长到GB大小，但是在分配列表时无法做出很好的猜测，并且将它们都设置为GB大小将导致堆崩溃。如果你发现了一些类似的问题，那么无论你的解决方案是什么，它确实需要重新设计(我不喜欢轻率地建议重新设计旧代码，因为我自己维护着成堆的旧代码，但这是一个很好的例子，说明原始设计已经跑出了跑道，确实需要丢弃)。尽管如此，我还是会把我几十年来的糟糕观点留在那里供你阅读。简单，合乎逻辑，大错特错。|2065244|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

As someone who has been doing operational performance engineering on very large scale SOA web services for about a decade, I would prefer the behavior of LinkedList over ArrayList. While the steady-state throughput of LinkedList is worse and therefore might lead to buying more hardware -- the behavior of ArrayList under pressure could lead to apps in a cluster expanding their arrays in near synchronicity and for large array sizes could lead to lack of responsiveness in the app and an outage, while under pressure, which is catastrophic behavior.
Similarly, you can get better throughput in an app from the default throughput tenured garbage collector, but once you get java apps with 10GB heaps you can wind up locking up the app for 25 seconds during a Full GCs which causes timeouts and failures in SOA apps and blows your SLAs if it occurs too often. Even though the CMS collector takes more resources and does not achieve the same raw throughput, it is a much better choice because it has more predictable and smaller latency.
ArrayList is only a better choice for performance if all you mean by performance is throughput and you can ignore latency. In my experience at my job I cannot ignore worst-case latency.
Update (Aug 27, 2021 -- 10 years later): This answer (my most historically upvoted answer on SO as well) is very likely wrong (for reasons outlined in the comments below). I'd like to add that ArrayList will optimize for sequential reading of memory and minimize cache-line and TLB misses, etc. The copying overhead when the array grows past the bounds is likely inconsequential by comparison (and can be done by efficient CPU operations). This answer is also probably getting worse over time given hardware trends. The only situations where a LinkedList might make sense would be something highly contrived where you had thousands of Lists any one of which might grow to be GB-sized, but where no good guess could be made at allocation-time of the List and setting them all to GB-sized would blow up the heap. And if you found some problem like that, then it really does call for reengineering whatever your solution is (and I don't like to lightly suggest reengineering old code because I myself maintain piles and piles of old code, but that'd be a very good case of where the original design has simply run out of runway and does need to be chucked). I'll still leave my decades-old poor opinion up there for you to read though. Simple, logical and pretty wrong.

blocks|key|1851136|text|参见the+Java+Tutorials+-+List+Implementations。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1851137|entityMap|0|LINK|mutability|MUTABLE|url|http://download.oracle.com/javase/tutorial/collections/implementations/list.html^0|2|15|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

See <a href="http://download.oracle.com/javase/tutorial/collections/implementations/list.html" rel="noreferrer">the Java Tutorials - List Implementations</a>.

blocks|key|1851210|text|正确或错误:请在本地执行测试并自行决定！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1851211|在LinkedList中编辑/删除比在ArrayList中更快。|offset|length|style|CODE|1851212|Array支持的ArrayList需要两倍的大小，在大容量应用中表现更差。|1851213|下面是每个operation.Timing的单元测试结果，以纳秒为单位。|1851214|1851215|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|code-block|syntax|javascript|1851216|1851217|代码如下：|1851218|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<String>+stringList+=+Arrays.asList(strings);
++++++++List<String>+arrayList+=+new+ArrayList<String>(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<String>+stringList+=+Arrays.asList(strings);

++++++++watch.start();
++++++++List<String>+linkedList+=+new+LinkedList<String>();
++++++++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<String>+arrayList+=+new+ArrayList<String>(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<String>+linkedList+=+new+LinkedList<String>();
++++++++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<String>+stringList+=+Arrays.asList(strings);
++++++++List<String>+arrayList+=+new+ArrayList<String>(MAX+%2B+MAX+/+10);
++++++++arrayList.addAll(stringList);

++++++++String+insertString0+=+getString(true,+MAX+/+2+%2B+10);
++++++++String+insertString1+=+getString(true,+MAX+/+2+%2B+20);
++++++++String+insertString2+=+getString(true,+MAX+/+2+%2B+30);
++++++++String+insertString3+=+getString(true,+MAX+/+2+%2B+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<String>+stringList+=+Arrays.asList(strings);
++++++++List<String>+linkedList+=+new+LinkedList<String>();
++++++++linkedList.addAll(stringList);

++++++++String+insertString0+=+getString(true,+MAX+/+2+%2B+10);
++++++++String+insertString1+=+getString(true,+MAX+/+2+%2B+20);
++++++++String+insertString2+=+getString(true,+MAX+/+2+%2B+30);
++++++++String+insertString3+=+getString(true,+MAX+/+2+%2B+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<String>+stringList+=+Arrays.asList(strings);
++++++++List<String>+arrayList+=+new+ArrayList<String>(MAX);

++++++++arrayList.addAll(stringList);
++++++++String+searchString0+=+getString(true,+MAX+/+2+%2B+10);
++++++++String+searchString1+=+getString(true,+MAX+/+2+%2B+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<String>+linkedList+=+new+LinkedList<String>();
++++++++linkedList.addAll(Arrays.asList(strings));

++++++++String+searchString0+=+getString(true,+MAX+/+2+%2B+10);
++++++++String+searchString1+=+getString(true,+MAX+/+2+%2B+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<String>+stringList+=+Arrays.asList(strings);
++++++++List<String>+arrayList+=+new+ArrayList<String>(MAX);

++++++++arrayList.addAll(stringList);
++++++++String+searchString0+=+getString(true,+MAX+/+2+%2B+10);
++++++++String+searchString1+=+getString(true,+MAX+/+2+%2B+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<String>+linkedList+=+new+LinkedList<String>();
++++++++linkedList.addAll(Arrays.asList(strings));

++++++++String+searchString0+=+getString(true,+MAX+/+2+%2B+10);
++++++++String+searchString1+=+getString(true,+MAX+/+2+%2B+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+%2B+(endTime+-+startTime));
++++++++}
++++}


++++private+String[]+maxArray()+{
++++++++String[]+strings+=+new+String[MAX];
++++++++Boolean+result+=+Boolean.TRUE;
++++++++for+(int+i+=+0;+i+<+MAX;+i%2B%2B)+{
++++++++++++strings[i]+=+getString(result,+i);
++++++++++++result+=+!result;
++++++++}
++++++++return+strings;
++++}

++++private+String+getString(Boolean+result,+int+i)+{
++++++++return+String.valueOf(result)+%2B+i+%2B+String.valueOf(!result);
++++}
}|1851219|entityMap^0|0|1|A|J|9|0|0|5|8|9|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|14|8|@$D|15|E|16|F|G]|$D|17|E|18|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|19|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1B|8|@]|9|@]|A|$P|Q]]|$1|R|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1D|8|@]|9|@]|A|$]]|$1|U|3|V|5|O|7|1E|8|@]|9|@]|A|$P|Q]]|$1|W|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|X|$]]

Correct or Incorrect: Please execute test locally and decide for yourself!

Edit/Remove is faster in <code>LinkedList</code> than <code>ArrayList</code>.

<code>ArrayList</code>, backed by <code>Array</code>, which needs to be double the size, is worse in large volume application.

Below is the unit test result for each operation.Timing is given in Nanoseconds.

<hr>

<pre><code>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
</code></pre>

<hr>

Here's the code:

<pre><code>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&lt;String&gt; stringList = Arrays.asList(strings);
 List&lt;String&gt; arrayList = new ArrayList&lt;String&gt;(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&lt;String&gt; stringList = Arrays.asList(strings);

 watch.start();
 List&lt;String&gt; linkedList = new LinkedList&lt;String&gt;();
 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&lt;String&gt; arrayList = new ArrayList&lt;String&gt;(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&lt;String&gt; linkedList = new LinkedList&lt;String&gt;();
 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&lt;String&gt; stringList = Arrays.asList(strings);
 List&lt;String&gt; arrayList = new ArrayList&lt;String&gt;(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&lt;String&gt; stringList = Arrays.asList(strings);
 List&lt;String&gt; linkedList = new LinkedList&lt;String&gt;();
 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&lt;String&gt; stringList = Arrays.asList(strings);
 List&lt;String&gt; arrayList = new ArrayList&lt;String&gt;(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&lt;String&gt; linkedList = new LinkedList&lt;String&gt;();
 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&lt;String&gt; stringList = Arrays.asList(strings);
 List&lt;String&gt; arrayList = new ArrayList&lt;String&gt;(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&lt;String&gt; linkedList = new LinkedList&lt;String&gt;();
 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 &lt; 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);
 }
}
</code></pre>

blocks|key|1851263|text|我已经阅读了回复，但有一个场景是，我总是使用LinkedList而不是我想要分享的ArrayList来听取意见：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1851264|每当我有一个方法返回从DB获得的数据列表时，我总是使用LinkedList。|1851265|我的理由是，因为不可能确切地知道我得到了多少结果，所以不会浪费内存(就像在ArrayList中一样，元素的容量和实际数量之间的差异)，并且不会浪费时间尝试复制容量。|1851266|作为一个ArrayList，我同意至少你应该总是使用具有初始容量的构造函数，以尽可能减少重复的数组。|1851267|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I have read the responses, but there is one scenario where I always use a LinkedList over an ArrayList that I want to share to hear opinions:

Every time I had a method that returns a list of data obtained from a DB I always use a LinkedList.

My rationale was that because it is impossible to know exactly how many results am I getting, there will be not memory wasted (as in ArrayList with the difference between the capacity and actual number of elements), and there would be no time wasted trying to duplicate the capacity.

As far a ArrayList, I agree that at least you should always use the constructor with the initial capacity, to minimize the duplication of the arrays as much as possible.

blocks|key|1851340|text|我知道这是一个古老的帖子，但我真的不敢相信没有人提到LinkedList实现了Deque。只需看看Deque+(和Queue)中的方法即可；如果您想要进行公平的比较，可以尝试对ArrayDeque运行LinkedList，并进行逐个特性的比较。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1851341|entityMap^0|Q|A|13|5|1D|5|1L|5|2G|A|2S|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|G|$]]

I know this is an old post, but I honestly can't believe nobody mentioned that <code>LinkedList</code> implements <code>Deque</code>. Just look at the methods in <code>Deque</code> (and <code>Queue</code>); if you want a fair comparison, try running <code>LinkedList</code> against <code>ArrayDeque</code> and do a feature-for-feature comparison.

blocks|key|2065843|text|对于ArrayLists和LinkedLists，remove()和insert()的运行效率都是O(n)。然而，线性处理时间背后的原因来自两个非常不同的原因：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2065844|在ArrayList中，您得到的是O(1)中的元素，但实际上删除或插入某些东西会使其变为O(n)，因为以下所有元素都需要更改。|2065845|在LinkedList中，需要O(n)才能真正到达所需的元素，因为我们必须从头开始，直到到达所需的索引。实际上，删除或插入都是常量，因为我们只需要为remove()更改1个引用，为insert()更改2个引用。|2065846|这两种方法中哪一种插入和删除速度更快取决于它发生的位置。如果我们离开始越近，LinkedList就会更快，因为我们必须处理相对较少的元素。如果我们更接近末尾，ArrayList将会更快，因为我们在固定的时间内到达那里，并且只需更改它后面的几个剩余元素。当在中间精确地完成时，LinkedList将会更快，因为遍历n个元素比移动n个值更快。|2065847|额外的好处:虽然没有办法使这两个方法对于ArrayList为O(1)，但实际上在LinkedLists中有一个方法可以做到这一点。假设我们想要遍历整个列表，在此过程中删除和插入元素。通常，对于使用LinkedList的每个元素，您将从头开始，我们也可以使用迭代器“保存”当前元素。在迭代器的帮助下，当在LinkedList中工作时，我们获得了remove()和insert()的O(1)效率。这使它成为我所知道的LinkedList总是比ArrayList更好的唯一性能优势。|2065848|entityMap^0|P|8|Y|8|0|0|22|8|2I|8|0|0|4R|8|50|8|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|10|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|O|$]]

Both <code>remove()</code> and <code>insert()</code> have a runtime efficiency of O(n) for both ArrayLists and LinkedLists. However, the reason behind the linear processing time comes from two very different reasons:
In an ArrayList, you get to the element in O(1), but actually removing or inserting something makes it O(n) because all the following elements need to be changed.
In a LinkedList, it takes O(n) to actually get to the desired element, because we have to start at the very beginning until we reach the desired index. Actually removing or inserting is constant, because we only have to change 1 reference for <code>remove()</code> and 2 references for <code>insert()</code>.
Which of the two is faster for inserting and removing depends on where it happens. If we are closer to the beginning the LinkedList will be faster, because we have to go through relatively few elements. If we are closer to the end an ArrayList will be faster, because we get there in constant time and only have to change the few remaining elements that follow it. When done precisely in the middle the LinkedList will be faster because going through n elements is quicker than moving n values.
Bonus: While there is no way of making these two methods O(1) for an ArrayList, there actually is a way to do this in LinkedLists. Let's say we want to go through the entire List removing and inserting elements on our way. Usually, you would start from the very beginning for each element using the LinkedList, we could also &quot;save&quot; the current element we're working on with an Iterator. With the help of the Iterator, we get an O(1) efficiency for <code>remove()</code> and <code>insert()</code> when working in a LinkedList. Making it the only performance benefit I'm aware of where a LinkedList is always better than an ArrayList.

blocks|key|1851764|text|ArrayList和LinkedList各有优缺点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1851765|与使用指向下一个节点的指针的LinkedList相比，ArrayList使用连续的内存地址。因此，当您想要在ArrayList中查找一个元素时，它比使用LinkedList进行n次迭代要快。|1851766|另一方面，在LinkedList中插入和删除要容易得多，因为您只需要更改指针，而ArrayList意味着对任何插入或删除都使用shift操作。|1851767|如果您的应用程序中有频繁的检索操作，请使用ArrayList。如果您经常插入和删除，请使用LinkedList。|1851768|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

ArrayList and LinkedList have their own pros and cons.

ArrayList uses contiguous memory address compared to LinkedList which uses pointers toward the next node. So when you want to look up an element in an ArrayList is faster than doing n iterations with LinkedList.

On the other hand, insertion and deletion in a LinkedList are much easier because you just have to change the pointers whereas an ArrayList implies the use of shift operation for any insertion or deletion.

If you have frequent retrieval operations in your app use an ArrayList. If you have frequent insertion and deletion use a LinkedList.

blocks|key|2065984|text|ArrayList扩展了AbstractList并实现了List接口。ArrayList是动态数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2065985|可以说，它基本上是为了克服数组的缺点而创建的|2065986|LinkedList类扩展了AbstractSequentialList并实现了List、Deque和Queue接口。|2065987|性能|2065988|arraylist.get()是O(1)，而linkedlist.get()是O(n)|offset|length|style|CODE|2065989|arraylist.add()是O(1)，linkedlist.add()是0(1)|2065990|arraylist.contains()是O(n)，linkedlist.contains()是O(n)|2065991|arraylist.next()是O(1)，linkedlist.next()是O(1)|2065992|arraylist.remove()是O(n)，而linkedlist.remove()是O(1)|2065993|在数组列表中|2065994|iterator.remove()是O(n)|2065995|而在链表中|2065996|iterator.remove()是O(1)|2065997|entityMap^0|0|0|0|0|0|F|M|G|0|0|F|L|G|0|0|K|Q|L|0|0|G|M|H|0|0|I|P|J|0|0|0|H|0|0|0|H|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|17|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|18|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|19|8|@$J|1A|K|1B|L|M]|$J|1C|K|1D|L|M]]|9|@]|A|$]]|$1|N|3|O|5|6|7|1E|8|@$J|1F|K|1G|L|M]|$J|1H|K|1I|L|M]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1J|8|@$J|1K|K|1L|L|M]|$J|1M|K|1N|L|M]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1O|8|@$J|1P|K|1Q|L|M]|$J|1R|K|1S|L|M]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1T|8|@$J|1U|K|1V|L|M]|$J|1W|K|1X|L|M]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1Z|8|@$J|20|K|21|L|M]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|22|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|23|8|@$J|24|K|25|L|M]]|9|@]|A|$]]|$1|13|3|-4|5|6|7|26|8|@]|9|@]|A|$]]]|14|$]]

ArrayList extends AbstractList and implements the List Interface. ArrayList is dynamic array. It can be said that it was basically created to overcome the drawbacks of arrays 
The LinkedList class extends AbstractSequentialList and implements List,Deque, and Queue interface.
 Performance 
<code>arraylist.get()</code> is O(1) whereas <code>linkedlist.get()</code> is O(n) 
<code>arraylist.add()</code> is O(1) and <code>linkedlist.add()</code> is 0(1) 
<code>arraylist.contains()</code> is O(n) and<code>linkedlist.contains()</code> is O(n) 
<code>arraylist.next()</code> is O(1) and <code>linkedlist.next()</code> is O(1) 
<code>arraylist.remove()</code> is O(n) whereas <code>linkedlist.remove()</code> is O(1) 
In arraylist <code>iterator.remove()</code> is O(n) whereas In linkedlist <code>iterator.remove()</code>is O(1)

blocks|key|1851935|text|我在这里看到的一个测试只进行一次测试。但我注意到的是，您需要多次运行这些测试，最终它们的时间会收敛。基本上，JVM需要预热。对于我的特定用例，我需要向列表中添加/删除项目，该列表将增长到大约500个项目。在我的测试中，LinkedList的速度更快，LinkedList大约为50,000+NS，ArrayList大约为90,000+NS……或多或少。请参阅下面的代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1851936|public+static+void+main(String[]+args)+{
++++List<Long>+times+=+new+ArrayList<>();
++++for+(int+i+=+0;+i+<+100;+i%2B%2B)+{
++++++++times.add(doIt());
++++}
++++System.out.println("avg+=+"+%2B+(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%2B%2B)+{
++++++++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;
}|code-block|syntax|javascript|1851937|entityMap^0|31|A|3H|A|44|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

One of the tests I saw on here only conducts the test once. But what I have noticed is that you need to run these tests many times and eventually their times will converge. Basically the JVM needs to warm up. For my particular use case I needed to add/remove items to a list that grows to about 500 items. In my tests <code>LinkedList</code> came out faster, with <code>LinkedList</code> coming in around 50,000 NS and <code>ArrayList</code> coming in at around 90,000 NS... give or take. See the code below.

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

static long doIt() {
 long start = System.nanoTime();
 List&lt;Object&gt; list = new LinkedList&lt;&gt;();
 //uncomment line below to test with ArrayList
 //list = new ArrayList&lt;&gt;();
 for (int i = 0; i &lt; 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;
}
</code></pre>

blocks|key|1852000|text|我通常根据在该特定列表上执行的操作的时间复杂性来使用一个或另一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1852001|%7C---------------------%7C---------------------%7C--------------------%7C------------%7C
%7C++++++Operation++++++%7C+++++ArrayList+++++++%7C+++++LinkedList+++++%7C+++Winner+++%7C
%7C---------------------%7C---------------------%7C--------------------%7C------------%7C
%7C+++++get(index)++++++%7C+++++++O(1)++++++++++%7C+++++++++O(n)+++++++%7C+ArrayList++%7C
%7C+++++++++++++++++++++%7C+++++++++++++++++++++%7C++n/4+steps+in+avg++%7C++++++++++++%7C
%7C---------------------%7C---------------------%7C--------------------%7C------------%7C
%7C++++++add(E)+++++++++%7C+++++++O(1)++++++++++%7C+++++++++O(1)+++++++%7C+LinkedList+%7C
%7C+++++++++++++++++++++%7C---------------------%7C--------------------%7C++++++++++++%7C
%7C+++++++++++++++++++++%7C+O(n)+in+worst+case++%7C++++++++++++++++++++%7C++++++++++++%7C
%7C---------------------%7C---------------------%7C--------------------%7C------------%7C
%7C++++add(index,+E)++++%7C+++++++O(n)++++++++++%7C+++++++++O(n)+++++++%7C+LinkedList+%7C
%7C+++++++++++++++++++++%7C+++++n/2+steps+++++++%7C++++++n/4+steps+++++%7C++++++++++++%7C
%7C+++++++++++++++++++++%7C---------------------%7C--------------------%7C++++++++++++%7C
%7C+++++++++++++++++++++%7C+++++++++++++++++++++%7C++O(1)+if+index+=+0+%7C++++++++++++%7C
%7C---------------------%7C---------------------%7C--------------------%7C------------%7C
%7C++remove(index,+E)+++%7C+++++++O(n)++++++++++%7C+++++++++O(n)+++++++%7C+LinkedList+%7C
%7C+++++++++++++++++++++%7C---------------------%7C--------------------%7C++++++++++++%7C
%7C+++++++++++++++++++++%7C+++++n/2+steps+++++++%7C++++++n/4+steps+++++%7C++++++++++++%7C
%7C---------------------%7C---------------------%7C--------------------%7C------------%7C
%7C++Iterator.remove()++%7C+++++++O(n)++++++++++%7C+++++++++O(1)+++++++%7C+LinkedList+%7C
%7C++ListIterator.add()+%7C+++++++++++++++++++++%7C++++++++++++++++++++%7C++++++++++++%7C
%7C---------------------%7C---------------------%7C--------------------%7C------------%7C


%7C--------------------------------------%7C-----------------------------------%7C
%7C++++++++++++++ArrayList+++++++++++++++%7C++++++++++++LinkedList+++++++++++++%7C
%7C--------------------------------------%7C-----------------------------------%7C
%7C+++++Allows+fast+read+access++++++++++%7C+++Retrieving+element+takes+O(n)+++%7C
%7C--------------------------------------%7C-----------------------------------%7C
%7C+++Adding+an+element+require+shifting+%7C+o(1)+[but+traversing+takes+time]++%7C
%7C+++++++all+the+later+elements+++++++++%7C+++++++++++++++++++++++++++++++++++%7C
%7C--------------------------------------%7C-----------------------------------%7C
%7C+++To+add+more+elements+than+capacity+%7C
%7C++++new+array+need+to+be+allocated++++%7C
%7C--------------------------------------%7C|code-block|syntax|javascript|1852002|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I usually use one over the other based on the time complexities of the operations that I'd perform on that particular List. 

<pre><code>|---------------------|---------------------|--------------------|------------|
| Operation | ArrayList | LinkedList | Winner |
|---------------------|---------------------|--------------------|------------|
| get(index) | O(1) | O(n) | ArrayList |
| | | n/4 steps in avg | |
|---------------------|---------------------|--------------------|------------|
| add(E) | O(1) | O(1) | LinkedList |
| |---------------------|--------------------| |
| | O(n) in worst case | | |
|---------------------|---------------------|--------------------|------------|
| add(index, E) | O(n) | O(n) | LinkedList |
| | n/2 steps | n/4 steps | |
| |---------------------|--------------------| |
| | | O(1) if index = 0 | |
|---------------------|---------------------|--------------------|------------|
| remove(index, E) | O(n) | O(n) | LinkedList |
| |---------------------|--------------------| |
| | n/2 steps | n/4 steps | |
|---------------------|---------------------|--------------------|------------|
| Iterator.remove() | O(n) | O(1) | LinkedList |
| ListIterator.add() | | | |
|---------------------|---------------------|--------------------|------------|


|--------------------------------------|-----------------------------------|
| ArrayList | LinkedList |
|--------------------------------------|-----------------------------------|
| Allows fast read access | Retrieving element takes O(n) |
|--------------------------------------|-----------------------------------|
| Adding an element require shifting | o(1) [but traversing takes time] |
| all the later elements | |
|--------------------------------------|-----------------------------------|
| To add more elements than capacity |
| new array need to be allocated |
|--------------------------------------|
</code></pre>

blocks|key|1852166|text|我的经验法则是，如果我需要一个Collection+(即不需要是List)，那么如果你提前知道大小，或者可以肯定地知道大小，或者知道它不会有太大变化，那么就使用ArrayList。如果您需要随机访问(即使用get(index))，则避免使用LinkedList。基本上，只有在不需要索引访问并且不知道要分配的集合的(近似)大小的情况下才使用LinkedList。此外，如果您要进行大量的添加和删除操作(同样是通过Collection接口)，那么LinkedList可能更可取。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1852167|entityMap^0|F|A|W|4|28|9|2V|A|3C|A|4Q|A|5Q|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|G|$]]

My rule of thumb is if I need a <code>Collection</code> (i.e. doesn't need to be a <code>List</code>) then use <code>ArrayList</code> if you know the size in advance, or can know the size confidently, or know that it won't vary much. If you need random access (i.e. you use <code>get(index)</code>) then avoid <code>LinkedList</code>. Basically, use <code>LinkedList</code> only if you don't need index access and don't know the (approximate) size of the collection you're allocating. Also if you're going to be making lots of additions and removals (again through the <code>Collection</code> interface) then LinkedList may be preferable.

blocks|key|2066312|text|首先使用向量而不是ArrayList，因为你可以重写insureCapasity方法，在ArrayList中是私有的，并增加1.5个当前数组https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html#ensureCapacity-int-的大小|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2066313|在许多情况下，它可能比linkedList更好，las有很大优势，它可以插入频率较高的数据，因此列表的大小变化非常快，而且您不能为数字元素分配大小。在理论上，你可能会得到“内存不足”这样的错误，但在现代计算机中，你有16G和交换磁盘，所以如果你列出的是billoins元素，你可能会失败，与15-20年前相比。|2066314|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html#ensureCapacity-int-^0|1Y|2B|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

First of all use Vector instead ArrayList because you can overrite insureCapasity method ,
in ArrayList is private and add 1.5 size of current array <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html#ensureCapacity-int-" rel="nofollow noreferrer">https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html#ensureCapacity-int-</a>

in many case it can be better that linkedList, the las has big advantage one you insert data with high freqency so size of you list changes very fast and you can't allocate size for number elements. 
In the theory you can get error like not "enough memory" but in modern computers you have 16G and swaping disk, so if you list is billoins elements you can fail, comparing 15-20 years ago.

I've always been one to simply use:

<pre><code>List&lt;String&gt; names = new ArrayList&lt;&gt;();
</code></pre>

I use the interface as the type name for portability, so that when I ask questions such as these I can rework my code. 

When should <a href="https://docs.oracle.com/javase/9/docs/api/java/util/LinkedList.html" rel="noreferrer"><code>LinkedList</code></a> be used over <a href="https://docs.oracle.com/javase/9/docs/api/java/util/ArrayList.html" rel="noreferrer"><code>ArrayList</code></a> and vice-versa?

When to use LinkedList over ArrayList in Java?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我一直是一个简单地使用：List<String> names = new ArrayList<>();我使用接口作为可移植性的类型名称，这样当我提出这样的问题时，我就可以修改我的代码。什么时候应该在上使用，反之亦然？

问在java语言中，什么时候在ArrayList上使用LinkedList？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在java语言中，什么时候在ArrayList上使用LinkedList？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在java语言中，什么时候在ArrayList上使用LinkedList？
EN