Java集合類主要分為List,Set,Map三大類。ArrayList和LinkedList是則List接口的倆個實現。他們都可以作為順序存放元素的容器，并且元素可以重復，可以為null值。當有元素重復時，如果按元素而非索引進行一些操作時，則會對List中的第一個符合條件的元素進行操作，如remove(E o)會刪除第一個元素。此外,ArrayList與LinkedList并非線程安全的容器，因此在多線程環境下，需要用Collections.synchronizedList()方法來進行包裝或者使用其他線程安全的容器。

盡管ArrayList和LinkedList都是一個List，但他們底層實現機制并不同，ArrayList基于數組，因此具有隨機訪問的特點，LinkedList則基于鏈表，因此在刪除和插入元素時，僅僅可以通過移動指針來實現而無需像數組一樣移動元素。

其次要注意當我們用ArrayList和LinkedList存放我們自定義對象的時候，要考慮是否需要實現equals方法，因為在ArrayList和LinkedList中的某些方法依賴于其元素的equals方法，如contains方法。如果我們自定義User對象未覆蓋Object類默認的equals方法，那么下面這段代碼會返回fasle而非true。

ArrayList<User> list = new ArrayList<>();
list.add(new User("andy",21));
User user = new User("andy",21);
System.out.print(list.contains(user));

本文中所有類繼承結構以及源碼均基于JDK1.8。

ArrayList

類繼承關系

ArrayList.png

源碼學習

1.ArrayList動態擴容機制

ArrayList是基于數組的，因此當添加元素的時候，如果數組容量不夠，則會進行自動擴容。

/**
 * Default initial capacity.
 */
private static final int DEFAULT_CAPACITY = 10;
/**
 * Shared empty array instance used for empty instances.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
  * Shared empty array instance used for default sized empty instances. We
  * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
  * first element is added.
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

要想成功添加，至少需要確保數組具有當前size+1的容量

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!! 
    elementData[size++] = e;
    return true;
}

如果elementData(即ArrayList的容器數組)為空,那么calculateCapacity這個方法會返回DEFAULT_CAPACITY即10和minCapacity中的最大值。因此，如果初始的時候我們不指定ArrayList的容量，則當我們添加第一個元素的時候，ArrayList會自動擴容到10。

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}
// 判斷是否需要擴容，如果數組長度小于添加當前元素所需要的最小容量，則擴容，跳到grow方法
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

每次擴容為原來的1.5倍，但第一次擴容會直接擴容到10。

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

指定初始容量與不指定初始容量的ArrayList添加元素性能對比(單位ms)

// 測試環境虛擬機ubuntu16.04 jdk1.8 12g內存 8處理器
public static void noInitCapacity(){
    long startTime = System.currentTimeMillis();
    ArrayList<String> list = new ArrayList();
    for (int i =0;i<10000;i++){
        list.add(""+i);
    }
    long endTime = System.currentTimeMillis();
    System.out.println(endTime-startTime);
}
public static void initCapacity(){
    long startTime = System.currentTimeMillis();
    ArrayList<String> list = new ArrayList(100000);
    for (int i =0;i<10000;i++){
            list.add(""+i);
    }
    long endTime = System.currentTimeMillis();
    System.out.println(endTime-startTime);
}

經過測試，發現在1000數量級的時候，二者差異并不明顯，但是當元素量級達到10000以上，指定初始容量的ArrayList添加元素的性能平均比未指定初始容量時要高1.5-2倍，因此在使用ArrayList的時候，最好給予一個大致的容量，避免ArrayList進行擴容

2.為什么ArrayList插入和刪除效率較低

因為在ArrayList源碼中,插入和刪除中都用到了

System.arraycopy(elementData, index+1, elementData, index,numMoved);

所以每次進行插入和刪除，都會進行大量數組拷貝，與LinkedList的具體效率對比放在最后LinkedList部分。

LinkedList

類繼承關系

LinkedList.png

LinkedList除了實現List接口，還實現了Deque接口，而Deque接口允許從頭部和尾部進行增加和刪除元素，因此也可以直接可以把LinkedList當作隊列或棧來使用。

源碼學習

1. LinkedList是單鏈表還是雙鏈表？

通過閱讀它的鏈表節點內部類，可以知道LinkedList是一個雙鏈表，即可以從前到后遍歷，也可以從后到前遍歷。

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

2. LinkedList如何找到指定位置的節點？

因為LinkedList是雙向鏈表，既可以從后遍歷，也可以從前遍歷，因此可以先拿index與size的一半比較，判斷從哪端遍歷會更快。

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

ArrayList與LinkedList查找、插入和刪除性能對比

public static List getArrayList(int length){
    ArrayList<String> list = new ArrayList<>(length);
    for (int i =0;i<length;i++){
        list.add(""+i);
    }
    return list;
}
public static List getLinkedList(int length){
    LinkedList<String> list = new LinkedList<>();
    for (int i =0;i<length;i++){
        list.add(""+i);
    }
    return list;
}

測試隨機訪問的性能

public static void testGet(int index){
    List<String> list1 = getArrayList(1000000);
    long startTime = System.currentTimeMillis();
    list1.get(index);
    long endTime = System.currentTimeMillis();
    System.out.println(endTime-startTime);
    List<String> list2 = getLinkedList(1000000);
    long startTime2 = System.currentTimeMillis();
    list2.get(index);
    long endTime2 = System.currentTimeMillis();
    System.out.println(endTime2-startTime2);
}

100萬元素中分別取索引位置5000、10萬、50萬、80萬位置的元素，對比ArrayList vs LinkedList

可以發現ArrayList基本都是0ms,但是LinkedList則與index有關,index越靠近中間，時間越長，index越靠向倆邊，時間越短，這也是符合LinkedList根據index與size的比較來優化遍歷的。
因此更新操作ArrayList性能也是要由于LinkedList的，因為ArrayList可根據索引直接找到需要修改的元素，而LinkedList則需要遍歷。
測試隨機刪除的性能

// 隨機產生n個0-100萬之間不重復的數
public static Integer[] generateRandomIntArr(int n){
    HashSet<Integer> sets = new HashSet<>();
    Integer[] res = new Integer[n];
    Random rand = new Random();
    while (sets.size() < n){
        sets.add(rand.nextInt(1000000)+1);
    }
    return sets.toArray(res);
}
public static void testDelete(int n){
    Integer[] indexs = generateRandomIntArr(n);
    List<String> list1 = getArrayList(1000000);
    long startTime = System.currentTimeMillis();
    for (int i =0;i<indexs.length;i++){
        list1.remove(indexs[i]);
        // list1.remove(i) 頭部連續刪除
    }
    long endTime = System.currentTimeMillis();
    System.out.println(endTime-startTime);

    List<String> list2 = getLinkedList(1000000);
    long startTime2 = System.currentTimeMillis();
    for (int i =0;i<indexs.length;i++){
        list2.remove(indexs[i]);
        // list2.remove(i) 頭部連續刪除
    }
    long endTime2 = System.currentTimeMillis();
    System.out.println(endTime2-startTime2);
}

100萬數據中隨機刪除10,100,1000個元素 ArrayList vs LinkedList 單位ms

實驗結論似乎與我們所認為的LinkedLists刪除性能要高于ArrayList是相反的，但是如果將隨機刪除改為頭部連續刪除，結果則符合我們的預期,LinkedList效率遠遠高于ArrayList。

如果改為尾部連續刪除，二者并無明顯差異。

測試隨機插入的性能
測試代碼略，實驗情況與刪除類似。

隨機刪除和插入，雖然鏈表只需要移動指針不需要拷貝元素，但要找到正確的刪除或插入位置仍然需要遍歷鏈表，因此性能反而不如ArrayList。而頭部刪除和插入，因為本身first和last指針的存在，LinkedList只需要移動指針即可，而ArrayList則需要拷貝全部的元素。

結論

• ArrayList默認容量為10，擴容機制為原來容量的1.5倍
• 盡可能給ArrayList一個初始容量，避免其進行擴容
• 如果查找，更新操作很多，優先選擇ArrayList
• 如果是頭尾刪除，插入操作較多，優先選擇LinkedList
• 如果是隨機刪除，插入操作較多，優先選擇ArrayList