翻譯人員: 鐵錨
翻譯時間: 2013年12月2日
原文連結: ArrayList vs. LinkedList vs. Vector

1. List概述

List,就如圖名字所示一樣,是元素的有序列表。當我們討論List時，將其與Set作對比是一個很好的辦法,Set集合中的元素是無序且唯一的。
下圖是Collection的類繼承圖,從圖中你可以對本文所討論的知識有大致的瞭解.
圖1 2. ArrayList、LinkedList與Vector的對比
從圖中可以看出,這三者都實現了List 介面.所有使用方式也很相似,主要區別在於因為實現方式的不同,所以對不同的操作具有不同的效率。
ArrayList 是一個可改變大小的陣列.當更多的元素加入到ArrayList中時,其大小將會動態地增長.內部的元素可以直接通過get與set方法進行訪問,因為ArrayList本質上就是一個數組.
LinkedList 是一個雙鏈表,在新增和刪除元素時具有比ArrayList更好的效能.但在get與set方面弱於ArrayList.
當然,這些對比都是指資料量很大或者操作很頻繁的情況下的對比,如果資料和運算量很小,那麼對比將失去意義.
Vector 和ArrayList類似,但屬於強同步類。如果你的程式本身是執行緒安全的(thread-safe,沒有在多個執行緒之間共享同一個集合/物件),那麼使用ArrayList是更好的選擇。
Vector和ArrayList在更多元素新增進來時會請求更大的空間。Vector每次請求其大小的雙倍空間，而ArrayList每次對size增長50%.
而 LinkedList 還實現了 Queue 介面,該介面比List提供了更多的方法,包括 offer(),peek(),poll()等.
注意: 預設情況下ArrayList的初始容量非常小,所以如果可以預估資料量的話,分配一個較大的初始值屬於最佳實踐,這樣可以減少調整大小的開銷。
3. ArrayList示例

public static void testArrayList() {
    ArrayList<Integer> al = new ArrayList<Integer>();
    al.add(3);
    al.add(2);        
    al.add(1);
    al.add(4);
    al.add(5);
    al.add(6);
    al.add(6);


    Iterator<Integer> iter1 = al.iterator();
    while(iter1.hasNext()){
        System.out.println(iter1.next());
    }
}
 

4. LinkedList示例

public static void testLinkedList() {
    LinkedList<Integer> ll = new LinkedList<Integer>();
    ll.add(3);
    ll.add(2);        
    ll.add(1);
    ll.add(4);
    ll.add(5);
    ll.add(6);
    ll.add(6);


    Iterator<Integer> iter2 = ll.iterator();
    while(iter2.hasNext()){
        System.out.println(iter2.next());
    }
}

如上面的例子所示,其使用方式是相似的,實際的區別在於底層的實現方式以及操作的複雜性不同.
5. Vector
Vector和ArrayList幾乎是完全相同的,唯一的區別在於Vector是同步類(synchronized).因此,開銷就比ArrayList要大.正常情況下,大多數的Java程式設計師使用ArrayList而不是Vector,因為同步完全可以由程式設計師自己來控制。
6. ArrayList與LinkedList效能對比
時間複雜度對比如下:

ArrayList	LinkedList
get()	O(1)	O(n)
add()	O(1)	O(1) amortized
remove()	O(n)	O(n)

* 表中的 add() 代表 add(E e),而 remove()代表 remove(int index)'

• ArrayList 對於隨機位置的add/remove，時間複雜度為 O(n),但是對於列表末尾的新增/刪除操作,時間複雜度是 O(1). 
• LinkedList對於隨機位置的add/remove，時間複雜度為 O(n),但是對於列表 末尾/開頭 的新增/刪除操作,時間複雜度是 O(1).

我使用下面的程式碼來測試他們的效能:

public static void testPerformance() {
    ArrayList<Integer> arrayList = new ArrayList<Integer>();
    LinkedList<Integer> linkedList = new LinkedList<Integer>();

    int 
    times = 10 * 1000;
    // times = 100 * 1000;
    // times = 1000 * 1000;
    System.out.println("Test times = " + times);
    System.out.println("-------------------------");
    // ArrayList add
    long startTime = System.nanoTime();

    for (int i = 0; i < times; i++) {
        arrayList.add(i);
    }
    long endTime = System.nanoTime();
    long duration = endTime - startTime;
    System.out.println(duration + " <--ArrayList add");

    // LinkedList add
    startTime = System.nanoTime();

    for (int i = 0; i < times; i++) {
        linkedList.add(i);
    }
    endTime = System.nanoTime();
    duration = endTime - startTime;
    System.out.println(duration + " <--LinkedList add");
    System.out.println("-------------------------");
    // ArrayList get
    startTime = System.nanoTime();

    for (int i = 0; i < times; i++) {
        arrayList.get(i);
    }
    endTime = System.nanoTime();
    duration = endTime - startTime;
    System.out.println(duration + " <--ArrayList get");

    // LinkedList get
    startTime = System.nanoTime();

    for (int i = 0; i < times; i++) {
        linkedList.get(i);
    }
    endTime = System.nanoTime();
    duration = endTime - startTime;
    System.out.println(duration + " <--LinkedList get");
    System.out.println("-------------------------");

    // ArrayList remove
    startTime = System.nanoTime();

    for (int i = times - 1; i >= 0; i--) {
        arrayList.remove(i);
    }
    endTime = System.nanoTime();
    duration = endTime - startTime;
    System.out.println(duration + " <--ArrayList remove");

    // LinkedList remove
    startTime = System.nanoTime();

    for (int i = times - 1; i >= 0; i--) {
        linkedList.remove(i);
    }
    endTime = System.nanoTime();
    duration = endTime - startTime;
    System.out.println(duration + " <--LinkedList remove");
}

輸出結果如下:

Test times = 10000
-------------------------
1469985 <--ArrayList add
3530491 <--LinkedList add
-------------------------
593678 <--ArrayList get
86914251 <--LinkedList get
-------------------------
625651 <--ArrayList remove
2164320 <--LinkedList remove

Test times = 100000
-------------------------
11480805 <--ArrayList add
26384338 <--LinkedList add
-------------------------
714072 <--ArrayList get
10040809061 <--LinkedList get
-------------------------
1203935 <--ArrayList remove
1595905 <--LinkedList remove

在 1000*1000次的執行中,很長時間過後, LinkedList的get日誌還沒有打印出來，大概是15分鐘左右,結果還是沒有出來.

Test times = 1000000
-------------------------
132632998 <--ArrayList add
322885939 <--LinkedList add
-------------------------
3690752 <--ArrayList get
1520315361147 <--LinkedList get
-------------------------
8750043 <--ArrayList remove
13872885 <--LinkedList remove

他們效能的差異相當明顯,LinkedList在 add和remove 上更快,而在get上更慢(原文是這樣的).

譯者注: 譯者的編譯和執行環境是 MyEclipse的JDK6,不論怎麼看,都是 ArrayList更勝一籌,所以,該怎麼選擇,請根據自己的實際情況來決定，最好自己做測試，因為資料型別不同,JDK版本不同,優化不同，就可能有不同的結果。

根據時間複雜度表格,以及測試結果,我們可以判斷何時該用ArrayList,何時該用LinkedList.

簡單來說,LinkedList更適用於:

• 沒有大規模的隨機讀取
• 大量的增加/刪除操作

相關閱讀: