何时在Java中使用LinkedList而不是ArrayList？

时间：2008-11-27 01:36:36

标签： java arraylist collections linked-list

我一直只是一个人使用：

List<String> names = new ArrayList<>();

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

何时应LinkedList使用ArrayList，反之亦然？

33 个答案:

答案 0 :(得分：3115)

带有ArrayList的

摘要 ArrayDeque在许多更多用例中优于LinkedList。如果您不确定 - 只需从ArrayList开始。

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

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

LinkedList<E>

  • get(int index) O（n）（平均 n / 4 步骤）
  • add(E element)是 O（1）
  • add(int index, E element) O（n）（平均 n / 4 步骤）， 但index = 0＆lt; --- LinkedList<E>
    • 的主要好处时 O（1）
  • remove(int index) O（n）（平均 n / 4 步骤）
  • Iterator.remove()是 O（1）。 ＆lt; --- LinkedList<E>
    • 的主要好处
  • ListIterator.add(E element) O（1）这是LinkedList<E>
    • 的主要好处之一

注意：许多操作平均需要 n / 4 步骤，最佳情况下常量步数（例如index = 0），以及最坏情况下的 n / 2 步骤（列表中间）

ArrayList<E>

  • get(int index) O（1）＆lt; --- ArrayList<E>的主要好处
  • add(E element) O（1）已分摊，但 O（n）最坏情况，因为必须调整数组并复制数组
  • add(int index, E element) O（n）（平均 n / 2 步骤）
  • remove(int index) O（n）（平均 n / 2 步骤）
  • Iterator.remove() O（n）（平均 n / 2 步骤）
  • ListIterator.add(E element) O（n）（平均 n / 2 步骤）

注意：许多操作平均需要 n / 2 步骤，常量最佳情况下的步骤数（列表末尾）， n 最坏情况下的步骤（列表开头）

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

另一方面，

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

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

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

当您从列表的头部添加或删除时，会出现使用ArrayList的另一个好处，因为这些操作是 O（1），而它们是 O（ n） LinkedList。请注意ArrayList可能是ArrayDeque添加和删除头部的一个很好的替代方法，但它不是LinkedList。

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

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

答案 1 :(得分：584)

到目前为止，除了LinkedList比ArrayList“更多”的普遍共识之外，似乎没有人解决过这些列表中每个列表的内存占用情况，所以我做了一些数字运算来展示两个列表究竟占用多少N个空引用。

由于在它们的相对系统上引用是32位或64位（即使为空），我已经为32位和64位LinkedLists和ArrayLists包含了4组数据。

注意： ArrayList行显示的尺寸适用于剪裁列表 - 实际上，支持数组的容量为{{1}通常大于其当前元素数。

注意2： （感谢BeeOnRope）由于CompressedOops现在默认从JDK6中部开始，因此64位机器的以下值基本上与32位相匹配同行，除非你特意把它关掉。

Graph of LinkedList and ArrayList No. of Elements x Bytes

结果清楚地表明ArrayList比LinkedList更多，特别是元素数量非常多。如果记忆是一个因素，请避开ArrayList。

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

<强>的ArrayList：

LinkedLists

<强>链表：

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)

答案 2 :(得分：222)

ArrayList就是你想要的。 LinkedList几乎总是（性能）错误。

为什么LinkedList很糟糕：

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

答案 3 :(得分：134)

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

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

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

答案 4 :(得分：119)

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)

Algorithms: Big-Oh Notation

ArrayLists适用于一次性多次写入或多次写入，但在前面或中间添加/删除时效果不佳。

答案 5 :(得分：101)

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

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

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

答案 6 :(得分：57)

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

Array vs ArrayList vs LinkedList vs Vector更深入，也是如此 Linked List

答案 7 :(得分：52)

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

LinkedList的编辑/删除速度比ArrayList快。

由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<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 + 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<String> stringList = Arrays.asList(strings);
        List<String> linkedList = new LinkedList<String>();
        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<String> stringList = Arrays.asList(strings);
        List<String> arrayList = new ArrayList<String>(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<String> linkedList = new LinkedList<String>();
        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<String> stringList = Arrays.asList(strings);
        List<String> arrayList = new ArrayList<String>(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<String> linkedList = new LinkedList<String>();
        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);
    }
}

答案 8 :(得分：45)

ArrayList本质上是一个数组。 LinkedList实现为双链表。

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

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

  1. 没有大量随机访问元素
  2. 有大量的添加/删除操作

    3. === ArrayList ===

    • 添加（E e）
      • 在ArrayList的末尾添加
      • 需要调整内存大小。
      • O（n）最差，O（1）摊销
    • add（int index，E element）
      • 添加到特定索引位置
      • 需要转移＆amp;可能的内存调整成本
      • O（n）的
    • 删除（int索引）
      • 删除指定的元素
      • 需要转移＆amp;可能的内存调整成本
      • O（n）的
    • 删除（对象o）
      • 从此列表中删除指定元素的第一个匹配项
      • 首先需要搜索元素，然后移动＆amp;可能的内存调整成本
      • O（n）的

    === LinkedList ===

    • 添加（E e）

      • 添加到列表的末尾
      • O（1）

    • add（int index，E element）

      • 在指定位置插入
      • 需要先找到位置
      • O（n）的
    • 删除（）
      • 删除列表的第一个元素
      • O（1）
    • 删除（int索引）
      • 删除具有指定索引的元素
      • 需要先找到元素
      • O（n）的
    • 删除（对象o）
      • 删除指定元素的第一个匹配项
      • 需要先找到元素
      • O（n）的

    以下是来自programcreek.com的数字（add和remove是第一种类型，即在列表末尾添加元素并删除指定位置的元素清单。）：

    enter image description here

答案 9 :(得分：34)

LinkedList的作者Joshua Bloch：

  

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

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

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

答案 10 :(得分：32)

ArrayList可以随机访问，而LinkedList非常便宜，可以展开和删除元素。对于大多数情况，ArrayList没问题。

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

答案 11 :(得分：20)

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

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

答案 12 :(得分：20)

我知道这是一篇旧帖子，但老实说我真的不相信有人提到LinkedList实施Deque。只需看看Deque（和Queue）中的方法;如果您想要公平比较，请尝试针对LinkedList运行ArrayDeque并进行功能特征比较。

答案 13 :(得分：18)

以下是ArrayList和LinkedList以及CopyOnWrite-ArrayList中的Big-O表示法：

<强>的ArrayList 

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)

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

答案 14 :(得分：14)

TL; DR 由于现代计算机体系结构的原因，ArrayList在几乎所有可能的用例中都将显着提高效率-因此应避免使用LinkedList，独特和极端的情况。

理论上，LinkedList的add(E element)具有O（1）

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

实践非常不同，因为LinkedList是 Cache Hostile 数据结构。从性能POV来看-在极少数情况下，LinkedList的性能可能优于缓存友好 ArrayList。

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

enter image description here

使用下一代硬件（更大，更高效的缓存）-结果更加确定：

enter image description here

LinkedList需要更多的时间来完成相同的工作。 source Source Code

主要原因有两个：

  1. 主要-LinkedList的节点随机分布在整个内存中。 RAM（“随机访问内存”）并不是真正随机的，需要获取内存块以进行缓存。此操作需要时间，并且当此类获取频繁发生时-缓存中的内存页需要一直替换->缓存未命中->缓存效率不高。 ArrayList元素存储在连续内存中-这正是现代CPU体系结构正在优化的内容。

  2. 次要 LinkedList保留后退/前进指针，这意味着每个存储值的内存消耗是ArrayList的3倍。

    < / li>

DynamicIntArray，顺便说一句，是一个自定义ArrayList实现，其中包含Int（原始类型）而不是Objects-因此，所有数据实际上都是相邻存储的-因此效率更高。

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

来源：Latency Numbers Every Programmer Should Know

为使观点更清楚，请检查将元素添加到列表开头的基准。从理论上讲，这是一个用例，LinkedList应该真正发挥作用，而ArrayList应该给出较差甚至更差的结果：

enter image description here

注意：这是C ++ Std库的基准，但是我以前的经验表明C ++和Java的结果非常相似。 Source Code

复制连续的内存是现代CPU进行的一项优化操作-改变理论，实际上使ArrayList / Vector的效率再次提高

信用：此处发布的所有基准都是由Kjell Hedström创建的。在his blog

上可以找到更多数据

答案 15 :(得分：14)

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

1。实施

  

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

     

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

2。性能

  • get（int index）或搜索操作

      

    ArrayList get（int index）操作以恒定时间运行，即O（1），而

         

    LinkedList get（int index）操作运行时间为O（n）。

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

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

    < / LI>

  • insert（）或add（Object）operation

      与相比， LinkedList 中的插入速度通常很快。在LinkedList中添加或插入是O（1）操作。

         

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

  • 删除（整数）操作

    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。内存开销

  

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

     

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

Source

答案 16 :(得分：12)

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

所以，不知何故，他们解决了稍微不同的问题，效率和行为的差异（参见他们的方法列表）。

答案 17 :(得分：9)

请参阅the Java Tutorials - List Implementations。

答案 18 :(得分：8)

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

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

答案 19 :(得分：7)

这取决于你将在列表上做些什么操作。

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

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

答案 20 :(得分：7)

我通常会根据要在特定List上执行的操作的时间复杂性来使用另一个。 

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

答案 21 :(得分：7)

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

重要：对于Java而言LinkedList这不是真的！见Is there a fast concat method for linked list in Java?

答案 22 :(得分：6)

我已阅读过这些回复，但有一种情况是我总是在我想要分享的ArrayList上使用LinkedList来听取意见：

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

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

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

答案 23 :(得分：5)

ArrayList中的get（i）操作比LinkedList快，因为：
ArrayList： List接口的可调整大小的数组实现
LinkedList： List和Deque接口的双链表实现

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

答案 24 :(得分：5)

ArrayList和LinkedList都实现了List interface，他们的方法和结果几乎相同。然而，它们之间的差异很小，这使得一个优于另一个，具体取决于要求。

ArrayList与LinkedList

1）与Search:搜索操作相比，ArrayList LinkedList搜索操作非常快。 get(int index)中的ArrayList表示O(1)的效果，LinkedList效果为O(n)。

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

2）Deletion: LinkedList删除操作会提供O(1)性能，而ArrayList会提供可变性能：O(n)在最坏的情况下（同时删除第一个元素）和{ {1}}在最好的情况下（删除最后一个元素时）。

  

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

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

3）O(1) Inserts Performance:添加方法会提供LinkedList个效果，而O(1)会在最坏的情况下提供ArrayList。原因与删除说明相同。

4）O(n) Memory Overhead:维护索引和元素数据，而ArrayList维护元素数据和两个邻居节点指针

  

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

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

  • ArrayList和LinkedList都是List接口的实现。
  • 它们都维护元素的插入顺序，这意味着在显示ArrayList和LinkedList元素时，结果集将具有将元素插入List的相同顺序。
  • 这两个类都是非同步的，可以使用Collections.synchronizedList方法显式同步。
  • 这些类返回的LinkedList和iterator为listIterator（如果在创建迭代器后的任何时候对列表进行结构修改，除了通过{{1}之外的任何方式自己删除或添加方法，迭代器将fail-fast一个iterator’s）。

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

  • 如上所述，与throw相比，插入和移除操作在ConcurrentModificationException中提供了良好的效果(O(1))。
      

    因此，如果在应用程序中需要频繁添加和删除，那么LinkedList是最佳选择。

  • 搜索（LinkedList）操作在ArrayList(O(n))中很快，但在get method中没有
      

    所以如果添加和删除操作少，搜索操作要求更多，那么ArrayList将是您最好的选择。

答案 25 :(得分：5)

ArrayList和LinkedList各有利弊。

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

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

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

答案 26 :(得分：4)

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。

答案 27 :(得分：1)

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

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

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

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

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

答案 28 :(得分：0)

我在这里看到的其中一项测试仅进行一次测试。但是我注意到，您需要多次运行这些测试，最终它们的时间会收敛。基本上，JVM需要预热。对于我的特定用例，我需要添加/删除项目到最后增加到大约500个项目的项目。在我的测试中，LinkedList的速度更快，链接的LinkedList的速度约为50,000 NS，ArrayList的速度约为90,000 NS。请参见下面的代码。

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

答案 29 :(得分：0)

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()是O（1）

答案 30 :(得分：0)

我的经验法则是，如果我需要Collection（即不必是List），那么如果您事先知道尺寸或可以知道，请使用ArrayList自信地知道大小，或者知道它不会有太大变化。如果您需要随机访问权限（即您使用get(index)），请避免使用LinkedList。基本上，仅当您不需要索引访问并且不知道要分配的集合的（近似）大小时，才使用LinkedList。另外，如果您打算进行大量添加和删除操作（同样通过Collection接口），则最好使用LinkedList。

答案 31 :(得分：-1)

首先使用Vector而不是ArrayList，因为您可以覆盖insureCapasity方法， ArrayList中的数组是私有的，并添加当前数组https://docs.oracle.com/javase/8/docs/api/java/util/Vector.html#ensureCapacity-int-的1.5大小

在许多情况下，最好使用linkedList，因为las具有很大的优势，即您可以插入具有高频率的数据，因此列表的大小变化非常快，并且您不能为数字元素分配大小。 从理论上讲，您会得到类似“没有足够的内存”这样的错误，但是在现代计算机中，您将拥有16G和交换磁盘，因此，与15到20年前相比，如果您列出的是Billoins元素，则可能会失败。

答案 32 :(得分：-1)

我应该何时使用LinkedList？大多数使用堆栈时，或使用缓冲区时。 我什么时候应该使用ArrayList？只有在使用索引时，否则您可以将HashTable与链表一起使用，然后得到：

哈希表+链表

  • 按键 O（1），
    • 进行访问
  • 按键 O（1），
    • 插入
  • 按键 O（1）
    • 删除
  • 使用版本控制时有一个用O（1）实现RemoveAll / SetAll的技巧

这似乎是一个很好的解决方案，在大多数情况下，你应该知道： HashTable占用了大量的磁盘空间，因此当您需要管理1,000,000个元素列表时，它可能成为重要的事情。这可能发生在服务器实现中，在客户端很少发生这种情况。

另请查看Red-Black-Tree

  • 随机访问日志（n），
  • 插入日志（n），
  • 删除日志（n）
相关问题
最新问题