我已经阅读了答案，但有一种情况是，我总是使用LinkedList而不是ArrayList，我想分享它来听取意见：

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

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

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

1） 基础数据结构

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

2） LinkedList实现Deque

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

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），因为它需要遍历该条目。虽然，在大O符号中，O（n/2）只是O（n），因为我们忽略了那里的常数。

7） 内存

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

因此，除了Array在将内容从一个Array复制到另一个Array时执行重新调整大小操作的情况外，ArrayList的内存需求似乎比LinkedList少。

如果Array足够大，那么此时可能会占用大量内存并触发垃圾收集，这会降低响应时间。

从ArrayList与LinkedList之间的所有差异来看，ArrayList在几乎所有情况下都是比LinkedList更好的选择，除非您经常执行add（）操作而不是remove（）或get（）操作。

修改链接列表比修改ArrayList更容易，尤其是当您从开始或结束处添加或删除元素时，因为链接列表内部保留了这些位置的引用，并且可以在O（1）时间内访问。

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

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

Joshua Bloch，LinkedList的作者：

有人真的使用LinkedList吗？我写的，我从来没有用过。

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

很抱歉，我的答案没有其他答案那样信息丰富，但我认为这是最不言自明的答案。

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

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

Array支持的ArrayList需要两倍的大小，在大容量应用程序中更糟糕。

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

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

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符号（存档）

ArrayList适用于一次写入、多次读取或追加，但不适用于从前面或中间添加/删除。

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