To Java程式設計師：切勿用普通for迴圈遍歷LinkedList

五月的倉頡發表於2016-02-14
Java程式設計師

ArrayList與LinkedList的普通for迴圈遍歷

對於大部分Java程式設計師朋友們來說，可能平時使用得最多的List就是ArrayList，對於ArrayList的遍歷，一般用如下寫法：

public static void main(String[] args)
{
    List<Integer> arrayList = new ArrayList<Integer>();
    
    for (int i = 0; i < 100; i++)
    {
        arrayList.add(i);
    }
    for (int i = 0; i < 100; i++)
    {
        System.out.println(arrayList.get(i));
    }
}

如果以後要用到LinkedList了，可能有些朋友就會用一樣的方式去遍歷LinkedList了：

public static void main(String[] args)
{
    List<Integer> linkedList = new LinkedList<Integer>();
    
    for (int i = 0; i < 100; i++)
    {
        linkedList.add(i);
    }
    for (int i = 0; i < 100; i++)
    {
        System.out.println(linkedList.get(i));
    }
}

請記住：這是一種非常糟糕的做法。這其實已經不是Java的問題，而是資料結構的問題了，我相信語言從Java換成其他的也都一樣。

下面對ArrayList和LinkedList的普通for迴圈效率進行測試以及分析原因。

 

ArrayList和LinkedList使用普通for迴圈遍歷速度對比

先給出測試程式碼：

public class ListIteratorTest
{
    private final static int LIST_SIZE = 1000;
    
    public static void main(String[] args)
    {
        List<Integer> arrayList = new ArrayList<Integer>();
        List<Integer> linkedList = new LinkedList<Integer>();
        
        for (int i = 0; i < LIST_SIZE; i++)
        {
            arrayList.add(i);
            linkedList.add(i);
        }
        
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < arrayList.size(); i++)
        {
            arrayList.get(i);
        }
        System.out.println("ArrayList遍歷速度：" + (System.currentTimeMillis() - startTime) + "ms");
        
        startTime = System.currentTimeMillis();
        for (int i = 0; i < linkedList.size(); i++)
        {
            linkedList.get(i);
        }
        System.out.println("LinkedList遍歷速度：" + (System.currentTimeMillis() - startTime) + "ms");
    }
}

不斷增大LIST_SIZE，我用表格表示一下執行結果：

  1000 5000 10000 50000 100000
ArrayList 0ms 1ms 2ms 3ms 3ms
LinkedList 3ms 16ms 88ms 2446ms 18848ms

從執行結果我們看到，按倍數增大List容量，ArrayList的遍歷顯得比較穩定，而LinkedList的遍歷幾乎是爆發式的增長，再測試下去已經沒有必要了。

下面解釋一下產生此現象的原因。

 

ArrayList使用普通for迴圈遍歷快的原因

先看一下ArrayList的get方法原始碼：

public E get(int index) {
RangeCheck(index);

return (E) elementData[index];
}

看到ArrayList的get方法只是從陣列裡面拿一個位置上的元素罷了。我們有結論，ArrayList的get方法的時間複雜度是O(1)，O(1)的意思也就是說時間複雜度是一個常數，和陣列的大小並沒有關係，只要給定陣列的位置，直接就能定位到資料。

其實熟悉C、C++或者對指標理解的朋友一定很好理解為什麼，我解釋一下為什麼對陣列使用get就快。

在計算機底層，資料都是有地址的，就像人有住址一樣。假設我寫了這麼一句程式碼：

int[3] ints = {1, 3, 5};

在Java中一個int型資料是4個位元組，此時計算機內部做的事情是，在記憶體空間中找到一塊連續的、足以存放3個4位元組也就是12位元組的陣列的記憶體空間，並返回該記憶體空間的首地址。比方說該記憶體空間的首地址是0x00吧，那麼那麼1就放在0x00~0x03中、3就放在0x04~0x07中、5就放在0x08~0x0B中。

這時就很簡單了，取ints[1]的時候，計算機就會算出ints[1]的資料是存放在以0x04開頭，佔據4個位元組空間的記憶體中，因此，計算機會從0x04~0x07這塊地址空間中讀取資料出來。

整個過程，和陣列有多大，並沒有關係，計算機做的只是算出起始地址-->去該地址中取資料而已，因此我們看到使用普通for迴圈遍歷ArrayList的速度很快，也很穩定。

 

LinkedList使用普通for迴圈遍歷慢的原因

再看一下LinkedList的get方法做了什麼：

public E get(int index) {
    return entry(index).element;
}
 1 private Entry<E> entry(int index) {
 2     if (index < 0 || index >= size)
 3         throw new IndexOutOfBoundsException("Index: "+index+
 4                                             ", Size: "+size);
 5     Entry<E> e = header;
 6     if (index < (size >> 1)) {
 7         for (int i = 0; i <= index; i++)
 8             e = e.next;
 9     } else {
10         for (int i = size; i > index; i--)
11             e = e.previous;
12     }
13     return e;
14 }

由於LinkedList是雙向連結串列，因此第6行的意思是算出i在一半前還是一半後，一半前正序遍歷、一半後倒序遍歷，這樣會快很多，當然，先不管這個，分析一下為什麼使用普通for迴圈遍歷LinkedList會這麼慢。

原因就在第7~第8行，第10~第11行的兩個for循裡面，以前者為例：

1、get(0)，直接拿到0位的Node0的地址，拿到Node0裡面的資料

2、get(1)，直接拿到0位的Node0的地址，從0位的Node0中找到下一個1位的Node1的地址，找到Node1，拿到Node1裡面的資料

3、get(2)，直接拿到0位的Node0的地址，從0位的Node0中找到下一個1位的Node1的地址，找到Node1，從1位的Node1中找到下一個2位的Node2的地址，找到Node2，拿到Node2裡面的資料。

後面的以此類推。

也就是說，LinkedList在get任何一個位置的資料的時候，都會把前面的資料走一遍。假如我有10個資料，那麼將要查詢1+2+3+4+5+5+4+3+2+1=30次資料，相比ArrayList，卻只需要查詢10次資料就行了，隨著LinkedList的容量越大，差距會越拉越大。其實使用LinkedList到底要查詢多少次資料，大家應該已經很明白了，來算一下：按照前一半算應該是（1 + 0.5N） * 0.5N / 2，後一半算上即乘以2，應該是（1 + 0.5N） * 0.5N = 0.25N2 + 0.5N，忽略低階項和首項係數，得出結論，LinikedList遍歷的時間複雜度為O(N2)，N為LinkedList的容量。

時間複雜度有以下經驗規則：

O(1) < O(log2N) < O(n) < O(N * log2N) < O(N2) < O(N3) < 2N < 3N < N!

前四個比較好、中間兩個一般、後3個很爛。也就是說O(N2)是相對糟糕的一種時間複雜度了，N大一點，程式就會執行得比較慢。

 

後記

根據以上的分析，各位Java程式設計師朋友們，切記一定不要使用普通for迴圈去遍歷LinkedList。使用迭代器或者foreach迴圈（foreach迴圈的原理就是迭代器）去遍歷LinkedList即可，這種方式是直接按照地址去找資料的，將會大大提升遍歷LinkedList的效率。

相關文章