真服了，ArrayList和LinkedList差異居然這麼大

時間 2020-09-29

標籤服了 arraylist linkedlist 差異居然欄目 Java 简体版

原文原文鏈接

ArrayList 和 LinkedList 有什麼區別，是面試官很是喜歡問的一個問題。可能大部分小夥伴和我同樣，能回答出「ArrayList 是基於數組實現的，LinkedList 是基於雙向鏈表實現的。」java

關於這一點，我以前的文章裏也提到過了。但說實話，這樣蒼白的回答並不能令面試官感到滿意，他還想知道的更多。node

那假如小夥伴們繼續作出下面這樣的回答：程序員

「ArrayList 在新增和刪除元素時，由於涉及到數組複製，因此效率比 LinkedList 低，而在遍歷的時候，ArrayList 的效率要高於 LinkedList。」面試

面試官會感到滿意嗎？我只能說，若是面試官比較仁慈的話，他可能會讓咱們回答下一個問題；不然的話，他會讓咱們回家等通知，這一等，可能意味着杳無音訊了。數據庫

爲何會這樣呢？爲何爲何？回答的不對嗎？數組

暴躁的小夥伴請喝口奶茶冷靜一下。冷靜下來後，請隨我來，讓咱們一塊兒肩並肩、手拉手地深刻地研究一下 ArrayList 和 LinkedList 的數據結構、實現原理以及源碼，可能神祕的面紗就揭開了。微信

0一、ArrayList 是如何實現的？

ArrayList 實現了 List 接口，繼承了 AbstractList 抽象類，底層是基於數組實現的，而且實現了動態擴容。網絡

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final int DEFAULT_CAPACITY = 10;
    transient Object[] elementData;
    private int size;
}

ArrayList 還實現了 RandomAccess 接口，這是一個標記接口：數據結構

public interface RandomAccess {
}

內部是空的，標記「實現了這個接口的類支持快速（一般是固定時間）隨機訪問」。快速隨機訪問是什麼意思呢？就是說不須要遍歷，就能夠經過下標（索引）直接訪問到內存地址。app

public E get(int index) {
    Objects.checkIndex(index, size);
    return elementData(index);
}
E elementData(int index) {
    return (E) elementData[index];
}

ArrayList 還實現了 Cloneable 接口，這代表 ArrayList 是支持拷貝的。ArrayList 內部的確也重寫了 Object 類的 clone() 方法。

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

ArrayList 還實現了 Serializable 接口，一樣是一個標記接口：

public interface Serializable {
}

內部也是空的，標記「實現了這個接口的類支持序列化」。序列化是什麼意思呢？Java 的序列化是指，將對象轉換成以字節序列的形式來表示，這些字節序中包含了對象的字段和方法。序列化後的對象能夠被寫到數據庫、寫到文件，也可用於網絡傳輸。

眼睛雪亮的小夥伴可能會注意到，ArrayList 中的關鍵字段 elementData 使用了 transient 關鍵字修飾，這個關鍵字的做用是，讓它修飾的字段不被序列化。

這不先後矛盾嗎？一個類既然實現了 Serilizable 接口，確定是想要被序列化的，對吧？那爲何保存關鍵數據的 elementData 又不想被序列化呢?

這還得從「ArrayList 是基於數組實現的」開始提及。你們都知道，數組是定長的，就是說，數組一旦聲明瞭，長度（容量）就是固定的，不能像某些東西同樣伸縮自如。這就很麻煩，數組一旦裝滿了，就不能添加新的元素進來了。

ArrayList 不想像數組這樣活着，它想能屈能伸，因此它實現了動態擴容。一旦在添加元素的時候，發現容量用滿了 s == elementData.length，就按照原來數組的 1.5 倍（oldCapacity >> 1）進行擴容。擴容以後，再將原有的數組複製到新分配的內存地址上 Arrays.copyOf(elementData, newCapacity)。

private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

private Object[] grow() {
    return grow(size + 1);
}

private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        int newCapacity = ArraysSupport.newLength(oldCapacity,
                minCapacity - oldCapacity, /* minimum growth */
                oldCapacity >> 1           /* preferred growth */);
        return elementData = Arrays.copyOf(elementData, newCapacity);
    } else {
        return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
    }
}

動態擴容意味着什麼？你們夥想一下。嗯，仍是我來告訴你們答案吧，有點火燒眉毛。

意味着數組的實際大小可能永遠沒法被填滿的，總有多餘出來空置的內存空間。

好比說，默認的數組大小是 10，當添加第 11 個元素的時候，數組的長度擴容了 1.5 倍，也就是 15，意味着還有 4 個內存空間是閒置的，對吧？

序列化的時候，若是把整個數組都序列化的話，是否是就多序列化了 4 個內存空間。當存儲的元素數量很是很是多的時候，閒置的空間就很是很是大，序列化耗費的時間就會很是很是多。

因而，ArrayList 作了一個愉快而又聰明的決定，內部提供了兩個私有方法 writeObject 和 readObject 來完成序列化和反序列化。

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioral compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

從 writeObject 方法的源碼中能夠看得出，它使用了 ArrayList 的實際大小 size 而不是數組的長度（elementData.length）來做爲元素的上限進行序列化。

此處應該有掌聲啊！不是爲我，爲 Java 源碼的做者們，他們真的是太厲害了，能夠用兩個詞來形容他們——殫精竭慮、精益求精。

0二、LinkedList 是如何實現的？

LinkedList 是一個繼承自 AbstractSequentialList 的雙向鏈表，所以它也能夠被看成堆棧、隊列或雙端隊列進行操做。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    transient int size = 0;
    transient Node<E> first;
    transient Node<E> last;
}

LinkedList 內部定義了一個 Node 節點，它包含 3 個部分：元素內容 item，前引用 prev 和後引用 next。代碼以下所示：

private static class Node<E> {
    E item;
    LinkedList.Node<E> next;
    LinkedList.Node<E> prev;

    Node(LinkedList.Node<E> prev, E element, LinkedList.Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

LinkedList 還實現了 Cloneable 接口，這代表 LinkedList 是支持拷貝的。

LinkedList 還實現了 Serializable 接口，這代表 LinkedList 是支持序列化的。眼睛雪亮的小夥伴可能又注意到了，LinkedList 中的關鍵字段 size、first、last 都使用了 transient 關鍵字修飾，這不又矛盾了嗎？究竟是想序列化仍是不想序列化？

答案是 LinkedList 想按照本身的方式序列化，來看它本身實現的 writeObject() 方法：

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
    // Write out any hidden serialization magic
    s.defaultWriteObject();

    // Write out size
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (LinkedList.Node<E> x = first; x != null; x = x.next)
        s.writeObject(x.item);
}

發現沒？LinkedList 在序列化的時候只保留了元素的內容 item，並無保留元素的先後引用。這樣就節省了很多內存空間，對吧？

那有些小夥伴可能就疑惑了，只保留元素內容，不保留先後引用，那反序列化的時候怎麼辦？

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
    // Read in any hidden serialization magic
    s.defaultReadObject();

    // Read in size
    int size = s.readInt();

    // Read in all elements in the proper order.
    for (int i = 0; i < size; i++)
        linkLast((E)s.readObject());
}

void linkLast(E e) {
    final LinkedList.Node<E> l = last;
    final LinkedList.Node<E> newNode = new LinkedList.Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

注意 for 循環中的 linkLast() 方法，它能夠把鏈表從新連接起來，這樣就恢復了鏈表序列化以前的順序。很妙，對吧？

和 ArrayList 相比，LinkedList 沒有實現 RandomAccess 接口，這是由於 LinkedList 存儲數據的內存地址是不連續的，因此不支持隨機訪問。

0三、ArrayList 和 LinkedList 新增元素時究竟誰快？

前面咱們已經從多個維度瞭解了 ArrayList 和 LinkedList 的實現原理和各自的特色。那接下來，咱們就來聊聊 ArrayList 和 LinkedList 在新增元素時究竟誰快？

1）ArrayList

ArrayList 新增元素有兩種狀況，一種是直接將元素添加到數組末尾，一種是將元素插入到指定位置。

添加到數組末尾的源碼：

public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
    return true;
}

private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

很簡單，先判斷是否須要擴容，而後直接經過索引將元素添加到末尾。

插入到指定位置的源碼：

public void add(int index, E element) {
    rangeCheckForAdd(index);
    modCount++;
    final int s;
    Object[] elementData;
    if ((s = size) == (elementData = this.elementData).length)
        elementData = grow();
    System.arraycopy(elementData, index,
            elementData, index + 1,
            s - index);
    elementData[index] = element;
    size = s + 1;
}

先檢查插入的位置是否在合理的範圍以內，而後判斷是否須要擴容，再把該位置之後的元素複製到新添加元素的位置以後，最後經過索引將元素添加到指定的位置。這種狀況是很是傷的，性能會比較差。

2）LinkedList

LinkedList 新增元素也有兩種狀況，一種是直接將元素添加到隊尾，一種是將元素插入到指定位置。

添加到隊尾的源碼：

public boolean add(E e) {
    linkLast(e);
    return true;
}
void linkLast(E e) {
    final LinkedList.Node<E> l = last;
    final LinkedList.Node<E> newNode = new LinkedList.Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

先將隊尾的節點 last 存放到臨時變量 l 中（不是說不建議使用 I 做爲變量名嗎？Java 的做者們明知故犯啊），而後生成新的 Node 節點，並賦給 last，若是 l 爲 null，說明是第一次添加，因此 first 爲新的節點；不然將新的節點賦給以前 last 的 next。

插入到指定位置的源碼：

public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}
LinkedList.Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        LinkedList.Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        LinkedList.Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}
void linkBefore(E e, LinkedList.Node<E> succ) {
    // assert succ != null;
    final LinkedList.Node<E> pred = succ.prev;
    final LinkedList.Node<E> newNode = new LinkedList.Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

先檢查插入的位置是否在合理的範圍以內，而後判斷插入的位置是不是隊尾，若是是，添加到隊尾；不然執行 linkBefore() 方法。

在執行 linkBefore() 方法以前，會調用 node() 方法查找指定位置上的元素，這一步是須要遍歷 LinkedList 的。若是插入的位置靠前前半段，就從隊頭開始日後找；不然從隊尾往前找。也就是說，若是插入的位置越靠近 LinkedList 的中間位置，遍歷所花費的時間就越多。

找到指定位置上的元素（succ）以後，就開始執行 linkBefore() 方法了，先將 succ 的前一個節點（prev）存放到臨時變量 pred 中，而後生成新的 Node 節點（newNode），並將 succ 的前一個節點變動爲 newNode，若是 pred 爲 null，說明插入的是隊頭，因此 first 爲新節點；不然將 pred 的後一個節點變動爲 newNode。

通過源碼分析之後，小夥伴們是否是在想：「好像 ArrayList 在新增元素的時候效率並不必定比 LinkedList 低啊！」

當二者的起始長度是同樣的狀況下：

若是是從集合的頭部新增元素，ArrayList 花費的時間應該比 LinkedList 多，由於須要對頭部之後的元素進行復制。

public class ArrayListTest {
    public static void addFromHeaderTest(int num) {
        ArrayList<String> list = new ArrayList<String>(num);
        int i = 0;

        long timeStart = System.currentTimeMillis();

        while (i < num) {
            list.add(0, i + "沉默王二");
            i++;
        }
        long timeEnd = System.currentTimeMillis();

        System.out.println("ArrayList從集合頭部位置新增元素花費的時間" + (timeEnd - timeStart));
    }
}

/**
 * @author 微信搜「沉默王二」，回覆關鍵字 PDF
 */
public class LinkedListTest {
    public static void addFromHeaderTest(int num) {
        LinkedList<String> list = new LinkedList<String>();
        int i = 0;
        long timeStart = System.currentTimeMillis();
        while (i < num) {
            list.addFirst(i + "沉默王二");
            i++;
        }
        long timeEnd = System.currentTimeMillis();

        System.out.println("LinkedList從集合頭部位置新增元素花費的時間" + (timeEnd - timeStart));
    }
}

num 爲 10000，代碼實測後的時間以下所示：

ArrayList從集合頭部位置新增元素花費的時間595
LinkedList從集合頭部位置新增元素花費的時間15

ArrayList 花費的時間比 LinkedList 要多不少。

若是是從集合的中間位置新增元素，ArrayList 花費的時間搞很差要比 LinkedList 少，由於 LinkedList 須要遍歷。

public class ArrayListTest {
    public static void addFromMidTest(int num) {
        ArrayList<String> list = new ArrayList<String>(num);
        int i = 0;

        long timeStart = System.currentTimeMillis();
        while (i < num) {
            int temp = list.size();
            list.add(temp / 2 + "沉默王二");
            i++;
        }
        long timeEnd = System.currentTimeMillis();

        System.out.println("ArrayList從集合中間位置新增元素花費的時間" + (timeEnd - timeStart));
    }
}

public class LinkedListTest {
    public static void addFromMidTest(int num) {
        LinkedList<String> list = new LinkedList<String>();
        int i = 0;
        long timeStart = System.currentTimeMillis();
        while (i < num) {
            int temp = list.size();
            list.add(temp / 2, i + "沉默王二");
            i++;
        }
        long timeEnd = System.currentTimeMillis();

        System.out.println("LinkedList從集合中間位置新增元素花費的時間" + (timeEnd - timeStart));
    }
}

num 爲 10000，代碼實測後的時間以下所示：

ArrayList從集合中間位置新增元素花費的時間1
LinkedList從集合中間位置新增元素花費的時間101

ArrayList 花費的時間比 LinkedList 要少不少不少。

若是是從集合的尾部新增元素，ArrayList 花費的時間應該比 LinkedList 少，由於數組是一段連續的內存空間，也不須要複製數組；而鏈表須要建立新的對象，先後引用也要從新排列。

public class ArrayListTest {
    public static void addFromTailTest(int num) {
        ArrayList<String> list = new ArrayList<String>(num);
        int i = 0;

        long timeStart = System.currentTimeMillis();

        while (i < num) {
            list.add(i + "沉默王二");
            i++;
        }

        long timeEnd = System.currentTimeMillis();

        System.out.println("ArrayList從集合尾部位置新增元素花費的時間" + (timeEnd - timeStart));
    }
}

public class LinkedListTest {
    public static void addFromTailTest(int num) {
        LinkedList<String> list = new LinkedList<String>();
        int i = 0;
        long timeStart = System.currentTimeMillis();
        while (i < num) {
            list.add(i + "沉默王二");
            i++;
        }
        long timeEnd = System.currentTimeMillis();

        System.out.println("LinkedList從集合尾部位置新增元素花費的時間" + (timeEnd - timeStart));
    }
}

num 爲 10000，代碼實測後的時間以下所示：

ArrayList從集合尾部位置新增元素花費的時間69
LinkedList從集合尾部位置新增元素花費的時間193

ArrayList 花費的時間比 LinkedList 要少一些。

這樣的結論和預期的是否是不太相符？ArrayList 在添加元素的時候若是不涉及到擴容，性能在兩種狀況下（中間位置新增元素、尾部新增元素）比 LinkedList 好不少，只有頭部新增元素的時候比 LinkedList 差，由於數組複製的緣由。

固然了，若是涉及到數組擴容的話，ArrayList 的性能就沒那麼可觀了，由於擴容的時候也要複製數組。

0四、ArrayList 和 LinkedList 刪除元素時究竟誰快？

1）ArrayList

ArrayList 刪除元素的時候，有兩種方式，一種是直接刪除元素（remove(Object)），須要直先遍歷數組，找到元素對應的索引；一種是按照索引刪除元素（remove(int)）。

public boolean remove(Object o) {
    final Object[] es = elementData;
    final int size = this.size;
    int i = 0;
    found: {
        if (o == null) {
            for (; i < size; i++)
                if (es[i] == null)
                    break found;
        } else {
            for (; i < size; i++)
                if (o.equals(es[i]))
                    break found;
        }
        return false;
    }
    fastRemove(es, i);
    return true;
}
public E remove(int index) {
    Objects.checkIndex(index, size);
    final Object[] es = elementData;

    @SuppressWarnings("unchecked") E oldValue = (E) es[index];
    fastRemove(es, index);

    return oldValue;
}

但從本質上講，都是同樣的，由於它們最後調用的都是 fastRemove(Object, int) 方法。

private void fastRemove(Object[] es, int i) {
    modCount++;
    final int newSize;
    if ((newSize = size - 1) > i)
        System.arraycopy(es, i + 1, es, i, newSize - i);
    es[size = newSize] = null;
}

從源碼能夠看得出，只要刪除的不是最後一個元素，都須要數組重組。刪除的元素位置越靠前，代價就越大。

2）LinkedList

LinkedList 刪除元素的時候，有四種經常使用的方式：

remove(int)，刪除指定位置上的元素

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

先檢查索引，再調用 node(int) 方法（先後半段遍歷，和新增元素操做同樣）找到節點 Node，而後調用 unlink(Node) 解除節點的先後引用，同時更新前節點的後引用和後節點的前引用：

E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

remove(Object)，直接刪除元素

public boolean remove(Object o) {
    if (o == null) {
        for (LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

也是先先後半段遍歷，找到要刪除的元素後調用 unlink(Node)。

removeFirst()，刪除第一個節點

public E removeFirst() {
    final LinkedList.Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}
private E unlinkFirst(LinkedList.Node<E> f) {
    // assert f == first && f != null;
    final E element = f.item;
    final LinkedList.Node<E> next = f.next;
    f.item = null;
    f.next = null; // help GC
    first = next;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

刪除第一個節點就不須要遍歷了，只須要把第二個節點更新爲第一個節點便可。

removeLast()，刪除最後一個節點

刪除最後一個節點和刪除第一個節點相似，只須要把倒數第二個節點更新爲最後一個節點便可。

能夠看得出，LinkedList 在刪除比較靠前和比較靠後的元素時，很是高效，但若是刪除的是中間位置的元素，效率就比較低了。

這裏就再也不作代碼測試了，感興趣的小夥伴能夠本身試試，結果和新增元素保持一致：

從集合頭部刪除元素時，ArrayList 花費的時間比 LinkedList 多不少；
從集合中間位置刪除元素時，ArrayList 花費的時間比 LinkedList 少不少；
從集合尾部刪除元素時，ArrayList 花費的時間比 LinkedList 少一點。

我本地的統計結果以下所示，小夥伴們能夠做爲參考：

ArrayList從集合頭部位置刪除元素花費的時間380
LinkedList從集合頭部位置刪除元素花費的時間4
ArrayList從集合中間位置刪除元素花費的時間381
LinkedList從集合中間位置刪除元素花費的時間5922
ArrayList從集合尾部位置刪除元素花費的時間8
LinkedList從集合尾部位置刪除元素花費的時間12

0五、ArrayList 和 LinkedList 遍歷元素時究竟誰快？

1）ArrayList

遍歷 ArrayList 找到某個元素的話，一般有兩種形式：

get(int)，根據索引找元素

public E get(int index) {
    Objects.checkIndex(index, size);
    return elementData(index);
}

因爲 ArrayList 是由數組實現的，因此根據索引找元素很是的快，一步到位。

indexOf(Object)，根據元素找索引

public int indexOf(Object o) {
    return indexOfRange(o, 0, size);
}

int indexOfRange(Object o, int start, int end) {
    Object[] es = elementData;
    if (o == null) {
        for (int i = start; i < end; i++) {
            if (es[i] == null) {
                return i;
            }
        }
    } else {
        for (int i = start; i < end; i++) {
            if (o.equals(es[i])) {
                return i;
            }
        }
    }
    return -1;
}

根據元素找索引的話，就須要遍歷整個數組了，從頭至尾依次找。

2）LinkedList

遍歷 LinkedList 找到某個元素的話，一般也有兩種形式：

get(int)，找指定位置上的元素

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

既然須要調用 node(int) 方法，就意味着須要先後半段遍歷了。

indexOf(Object)，找元素所在的位置

public int indexOf(Object o) {
    int index = 0;
    if (o == null) {
        for (LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (x.item == null)
                return index;
            index++;
        }
    } else {
        for (LinkedList.Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item))
                return index;
            index++;
        }
    }
    return -1;
}

須要遍歷整個鏈表，和 ArrayList 的 indexOf() 相似。

那在咱們對集合遍歷的時候，一般有兩種作法，一種是使用 for 循環，一種是使用迭代器（Iterator）。

若是使用的是 for 循環，可想而知 LinkedList 在 get 的時候性能會很是差，由於每一次外層的 for 循環，都要執行一次 node(int) 方法進行先後半段的遍歷。

LinkedList.Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        LinkedList.Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        LinkedList.Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

那若是使用的是迭代器呢？

LinkedList<String> list = new LinkedList<String>();
for (Iterator<String> it = list.iterator(); it.hasNext();) {
    it.next();
}

迭代器只會調用一次 node(int) 方法，在執行 list.iterator() 的時候：先調用 AbstractSequentialList 類的 iterator() 方法，再調用 AbstractList 類的 listIterator() 方法，再調用 LinkedList 類的 listIterator(int) 方法，以下圖所示。

最後返回的是 LinkedList 類的內部私有類 ListItr 對象：

public ListIterator<E> listIterator(int index) {
    checkPositionIndex(index);
    return new LinkedList.ListItr(index);
}

private class ListItr implements ListIterator<E> {
    private LinkedList.Node<E> lastReturned;
    private LinkedList.Node<E> next;
    private int nextIndex;
    private int expectedModCount = modCount;

    ListItr(int index) {
        // assert isPositionIndex(index);
        next = (index == size) ? null : node(index);
        nextIndex = index;
    }

    public boolean hasNext() {
        return nextIndex < size;
    }

    public E next() {
        checkForComodification();
        if (!hasNext())
            throw new NoSuchElementException();

        lastReturned = next;
        next = next.next;
        nextIndex++;
        return lastReturned.item;
    }
}

執行 ListItr 的構造方法時調用了一次 node(int) 方法，返回第一個節點。在此以後，迭代器就執行 hasNext() 判斷有沒有下一個，執行 next() 方法下一個節點。

由此，能夠得出這樣的結論：遍歷 LinkedList 的時候，千萬不要使用 for 循環，要使用迭代器。

也就是說，for 循環遍歷的時候，ArrayList 花費的時間遠小於 LinkedList；迭代器遍歷的時候，二者性能差很少。