一、List介面概述：

List介面，稱為有序的Collection，也就是序列，該介面可以對列表中的每一個元素的插入位置進行精準的控制，同時使用者可以根據元素的整數索引（在列表中的位置）訪問元素，並搜尋列表中的元素。下面是List介面的框架圖：

通過上面的框架圖，可以對List的結構瞭然於心，其各個類、介面如下：

Collection：Collection 層次結構 中的根介面。它表示一組物件，這些物件也稱為 collection 的元素。對於Collection而言，它不提供任何直接的實現，所有的實現全部由它的子類負責。

AbstractCollection：提供 Collection 介面的骨幹實現，以最大限度地減少了實現此介面所需的工作。對於我們而言要實現一個不可修改的 collection，只需擴充套件此類，並提供 iterator 和 size 方法的實現。但要實現可修改的 collection，就必須另外重寫此類的 add 方法（否則，會丟擲 UnsupportedOperationException），iterator 方法返回的迭代器還必須另外實現其 remove 方法。

Iterator：迭代器。

ListIterator：List 系列表迭代器，允許程式設計師按任一方向遍歷列表、迭代期間修改列表，並獲得迭代器在列表中的當前位置。

List：繼承於Collection的介面。它代表著有序的佇列。

AbstractList：List 介面的骨幹實現，以最大限度地減少實現“隨機訪問”資料儲存（如陣列）支援的該介面所需的工作。

Queue：佇列。提供佇列基本的插入、獲取、檢查操作。

Deque：一個線性 collection，支援在兩端插入和移除元素。大多數 Deque 實現對於它們能夠包含的元素數沒有固定限制，但此介面既支援有容量限制的雙端佇列，也支援沒有固定大小限制的雙端佇列。

AbstractSequentialList：提供了 List 介面的骨幹實現，從而最大限度地減少了實現受“連續訪問”資料儲存（如連結列表）支援的此介面所需的工作。從某種意義上說，此類與在列表的列表迭代器上實現“隨機訪問”方法。

LinkedList：List 介面的連結列表實現。它實現所有可選的列表操作。

ArrayList：List 介面的大小可變陣列的實現。它實現了所有可選列表操作，並允許包括 null 在內的所有元素。除了實現 List 介面外，此類還提供一些方法來操作內部用來儲存列表的陣列的大小。

Vector：實現可增長的物件陣列。與陣列一樣，它包含可以使用整數索引進行訪問的元件。

Stack：後進先出（LIFO）的物件堆疊。它通過五個操作對類 Vector 進行了擴充套件 ，允許將向量視為堆疊。

Enumeration：列舉，實現了該介面的物件，它生成一系列元素，一次生成一個。連續呼叫 nextElement 方法將返回一系列的連續元素。

二、使用場景：

如果涉及到“棧”、“佇列”、“連結串列”等操作，請優先考慮用List。至於是那個List則分如下：

1、對於需要快速插入、刪除元素，則需使用LinkedList。

2、對於需要快速訪問元素，則需使用ArrayList。

3、對於“單執行緒環境”或者“多執行緒環境，但是List僅被一個執行緒操作”，需要考慮使用非同步的類，如果是“多執行緒環境，切List可能同時被多個執行緒操作”，考慮使用同步的類（如Vector）。

1、ArrayList、LinkedList效能分析：

1. public class ListTest {
2. private static final int COUNT = 100000;
4. private static ArrayList arrayList = new ArrayList<>();
5. private static LinkedList linkedList = new LinkedList<>();
6. private static Vector vector = new Vector<>();
8. public static void insertToList(List list){
9. long startTime = System.currentTimeMillis();
11. for(int i = 0 ; i < COUNT ; i++){
12. list.add(0,i);
13. }
15. long endTime = System.currentTimeMillis();
16. System.out.println("插入 " + COUNT + "元素" + getName(list) + "花費 " + (endTime - startTime) + " 毫秒");
17. }
19. public static void deleteFromList(List list){
20. long startTime = System.currentTimeMillis();
22. for(int i = 0 ; i < COUNT ; i++){
23. list.remove(0);
24. }
26. long endTime = System.currentTimeMillis();
27. System.out.println("刪除" + COUNT + "元素" + getName(list) + "花費 " + (endTime - startTime) + " 毫秒");
28. }
30. public static void readList(List list){
31. long startTime = System.currentTimeMillis();
33. for(int i = 0 ; i < COUNT ; i++){
34. list.get(i);
35. }
37. long endTime = System.currentTimeMillis();
38. System.out.println("讀取" + COUNT + "元素" + getName(list) + "花費 " + (endTime - startTime) + " 毫秒");
39. }
41. private static String getName(List list) {
42. String name = "";
43. if(list instanceof ArrayList){
44. name = "ArrayList";
45. }
46. else if(list instanceof LinkedList){
47. name = "LinkedList";
48. }
49. else if(list instanceof Vector){
50. name = "Vector";
51. }
52. return name;
53. }
55. public static void main(String[] args) {
56. insertToList(arrayList);
57. insertToList(linkedList);
58. insertToList(vector);
60. System.out.println("--------------------------------------");
62. readList(arrayList);
63. readList(linkedList);
64. readList(vector);
66. System.out.println("--------------------------------------");
68. deleteFromList(arrayList);
69. deleteFromList(linkedList);
70. deleteFromList(vector);
71. }
72. }

執行結果：

1. 插入 100000元素ArrayList花費 3900 毫秒
2. 插入 100000元素LinkedList花費 15 毫秒
3. 插入 100000元素Vector花費 3933 毫秒
4. --------------------------------------
5. 讀取100000元素ArrayList花費 0 毫秒
6. 讀取100000元素LinkedList花費 8877 毫秒
7. 讀取100000元素Vector花費 16 毫秒
8. --------------------------------------
9. 刪除100000元素ArrayList花費 4618 毫秒
10. 刪除100000元素LinkedList花費 16 毫秒
11. 刪除100000元素Vector花費 4759 毫秒

從上面的執行結果我們可以清晰的看出ArrayList、LinkedList、Vector增加、刪除、遍歷的效率問題。下面我就插入方法add(int index, E element),delete、get方法各位如有興趣可以研究研究。

首先我們先看三者之間的原始碼：

ArrayList：

1. public void add(int index, E element) {
2. rangeCheckForAdd(index); //檢查是否index是否合法
4. ensureCapacityInternal(size + 1); //擴容操作
5. System.arraycopy(elementData, index, elementData, index + 1, size - index); //陣列拷貝
6. elementData[index] = element; //插入
7. size++;
8. }

rangeCheckForAdd、ensureCapacityInternal兩個方法沒有什麼影響，真正產生影響的是System.arraycopy方法，該方法是個JNI函式，是在JVM中實現的。宣告如下：

public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

該方法會移動index後面的所有元素即可，這就意味著ArrayList的add(int index, E element)方法會引起index位置之後所有元素的改變，這真是牽一處而動全身。

LinkedList：

1. public void add(int index, E element) {
2. checkPositionIndex(index);
4. if (index == size) //插入位置在末尾
5. linkLast(element);
6. else
7. linkBefore(element, node(index));
8. }

該方法比較簡單，插入位置在末尾則呼叫linkLast方法，否則呼叫linkBefore方法，其實linkLast、linkBefore都是非常簡單的實現，就是在index位置插入元素，至於index具體為知則有node方法來解決，同時node對index位置檢索還有一個加速作用，如下：

1. Node<E> node(int index) {
2. if (index < (size >> 1)) { //如果index 小於 size/2 則從頭開始查詢
3. Node<E> x = first;
4. for (int i = 0; i < index; i++)
5. x = x.next;
6. return x;
7. } else { //如果index 大於 size/2 則從尾部開始查詢
8. Node<E> x = last;
9. for (int i = size - 1; i > index; i--)
10. x = x.prev;
11. return x;
12. }
13. }

所以linkedList的插入動作比ArrayList動作快就在於兩個方面。1：linkedList不需要執行元素拷貝動作，沒有牽一髮而動全身的大動作。2:查詢插入位置有加速動作即：若index < 雙向連結串列長度的1/2，則從前向後查詢; 否則，從後向前查詢。

Vector：

Vector的實現機制和ArrayList一樣，同樣是使用動態陣列來實現的，所以他們兩者之間的效率差不多，add的原始碼也一樣，如下：

1. public void add(int index, E element) {
2. insertElementAt(element, index);
3. }
5. public synchronized void insertElementAt(E obj, int index) {
6. modCount++;
7. if (index > elementCount) {
8. throw new ArrayIndexOutOfBoundsException(index
9. + " > " + elementCount);
10. }
11. ensureCapacityHelper(elementCount + 1);
12. System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
13. elementData[index] = obj;
14. elementCount++;
15. }

上面是針對ArrayList、LinkedList、Vector三者之間的add（int index,E element)方法的解釋，解釋了LinkedList的插入動作要比ArrayList、Vector的插入動作效率為什麼要高出這麼多！至於delete、get兩個方法LZ就不多解釋了。

2、Vector 和 ArrayList的區別：