ArrayList
ArrayList也叫數組列表，底層使用的數組實現的，嚴格來說是動態數組。
ArrayList工作原理
ArrayList工作原理其實很簡單，底層是動態數組，每次創建一個ArrayList實例時會分配一個初始容量（如果指定了初始容量的話），以add方法爲例，如果沒有指定初始容量，當執行add方法，先判斷當前數組是否爲空，如果爲空則給保存對象的數組分配一個最小容量，默認爲10。當添加大容量元素額時候，會先增加數組的大小，以提高添加的效率。
源碼分析
由於ArrayList方法較多，對源碼的分析選取了我們平時最常用的add、get和remove方法來分析。
add()
add方法重載了多個實現，包括add(E e)和add(int index,E e)，由於沒有指定插入的位置，每次插入操作會把元素放到數組的末尾，而這個過程只需要保證容量夠用就行.
add(E e)
public boolean add(E e) {
//保證數組的容量始終夠用
ensureCapacityInternal(size + 1);
//size是elementData數組中元組的個數，初始爲0
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
//如果數組沒有元素，給數組一個默認大小，會選擇實例化時的值與默認大小中較大值
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//保證容量夠用
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
//modCount是數組發生size更改的次數
modCount++;
// 如果數組長度小於默認的容量10，則調用擴大數組大小的方法
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
// 在原來容量的基礎上擴容2倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 新的容量大於數組最大值，則調用hugeCapacity()
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);
}
private static int hugeCapacity(int minCapacity) {
// 超過int最大數，發生大數溢出
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
// 容量爲int的最大值
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}add(int index,E e)
public void add(int index, E element) {
//判斷index的值是否合法，如果大於size或者小於0則將拋出異常
rangeCheckForAdd(index);
//保證容量夠用，並修改modCount的值
ensureCapacityInternal(size + 1);
//從第index位置開始，將元素往後移動一個位置
System.arraycopy(elementData, index, elementData, index + 1, size - index);
//把要插入的元素e放在第index位置
elementData[index] = element;
//數組元素的個數增加1
size++;
}get()
get方法最簡單，首先判斷該位置是否合法，如果合法則直接返回該位置的元素。
public E get(int index) {
rangeCheck(index);
return elementData(index);
}remove()
由於刪除操作會改變size，所以每次刪除都需要把元素向前移動一個位置，然後把原來最後一個位置的元素設置爲null，一次刪除操作完成。
public E remove(int index) {
//判斷index是否合法
rangeCheck(index);
//remove操作會改變size，所以modCount加1
modCount++;
//保存待刪除位置的元素
E oldValue = elementData(index);
//要移動的元素個數
int numMoved = size - index - 1;
//如果index不是最後一個元素，則從第index+1到最後一個位置，依次向前移動一個位置
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,numMoved);
//元素的size減少1，並把原來末尾位置元素的值設置爲null
elementData[--size] = null;
//返回index位置的值
return oldValue;
}注意到源碼調用了System.arraycopy方法，該方法是native的，即該代碼是其他語言編寫，但Java允許與其進行交互（詳情請搜索JNI），那麼該方法是如何讓實現的呢？
//add方法的System.arraycopy()
//把從第i位置的元素開始到最後一個元素，都往後移動一個位置
for(int j = size - 1; j > i; j--){
elements[j] = elements[j-1];
}
//把第i位置的值改爲e
elements[i] = e;
//remove方法的System.arraycopy()方法
//把從第i位置到最後一個位置，都向前移動一個位置
for (int j = i; j < size - 1; j++) {
elements[j] = elements[j + 1];
}
//把數組的元素個數減少1
elements[--size] = null;ArrayList小結
- get方法的時間複雜度爲O(1)，add和remove操作的時間複雜度爲O(n)
- 在ArrayList中查找元素很方便，但插入以及刪除元素效率就很低，移動元素對性能的開銷很大
- ArrayList是非同步的
- ArrayList一般應用於查詢較多但插入以及刪除較少情況，如果插入以及從刪除較多則建議使用LinkedList
LinkedList
LinkedList原理
LinkedList底層使用的雙向鏈表，即每個節點既包含指向其後繼的引用也包括指向其前驅的引用，LinkedList實現了List接口，繼承了AbstractSequentialList類，在頻繁進行插入以及刪除的情況下效率較高。此外LinkedList還實現了Deque（繼承自Queue接口）接口，可以當做隊列使用。
源碼分析
add()
默認添加到list的末尾，插入一個節點非常快，直接找到該位置的節點，修改節點的前驅以及後繼的引用即可
public boolean add(E e) {
//把e放在鏈表的最後一個位置
linkLast(e);
return true;
}
// 在list末尾添加，修改相應引用
void linkLast(E e) {
//last是鏈表最後一個節點的引用，現在l也指向最後一個節點
final Node<E> l = last;
//調用Node(Node<E> prev, E element, Node<E> next)構造方法
final Node<E> newNode = new Node<>(l, e, null);
//last節點指向newNode
last = newNode;
//如果l爲空，則鏈表爲空，直接把newNode鏈接在首節點後面即可，否則把newNode鏈接//在l節點的後面
if (l == null)
first = newNode;
else
l.next = newNode;
//鏈表的元素個數增加1
size++;
//modCount是鏈表發生結構性修改的次數（結構性修改是指發生添加或者刪除操作）
modCount++;
}get()
獲取index節點的值要從頭或尾遍歷鏈表，當數據量很大的時候，效率無疑是低下的。
public E get(int index) {
//檢查index是否合法
checkElementIndex(index);
//如果合法就返回該節點位置的值
return node(index).item;
}
//獲取index位置上的節點
Node<E> node(int index) {
//斷言index在鏈表中
// assert isElementIndex(index);
//從第一個節點開始尋找直到index位置，然後返回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;
}
}
//檢查index值的合法性
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//判斷index是否存在於鏈表中
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}remove()
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
E unlink(Node<E> x) {
// assert x != null;
//保存x節點的值
final E element = x.item;
//保存x節點的後繼
final Node<E> next = x.next;
//保存x節點的前驅
final Node<E> prev = x.prev;
//如果前驅爲null，說明要移除的是第一個節點，把First指向下一個節點就行
if (prev == null) {
first = next;
} else {//否則，把x節點前驅的後繼指向x的後繼，並把x的前驅設置爲null
prev.next = next;
x.prev = null;
}
//如果後繼爲null則要移除的是最後一個節點，則把last的引用指向x節點的前驅就ok
if (next == null) {
last = prev;
} else {//否則，把x節點的後繼的前驅設置爲x節點的前驅，並x節點的後繼設爲null
next.prev = prev;
x.next = null;
}
//把x節點的值設爲null，這樣x就沒有任何引用了，gc處理
x.item = null;
//把鏈表的size減少1
size--;
//結構性修改的次數增加1
modCount++;
//返回x節點的值，在移除之前已經保存在element中了
return element;
}LinkedList小結
- get方法的時間複雜度爲O(n),add和remove的時間複雜度爲O(1)，因爲只需要修改節點的前驅以及後繼就可以
- LinkedList是非同步的，如果要考慮併發，則需要使用外部同步
- LinkedList一般應用於增刪較多而查找較少的情況，從時間複雜度上便可以看出來
ArrayList與LinekdList的區別
- ArrayList底層使用的數據結構是數組而LinekdList底層使用的是雙向鏈表
- ArrayList查詢效率較高而LinkedList增刪效率較高
- ArrayList應用於查找操作較多的場景中而LinkedList應用於增刪較多的場景中
- 對於隨機訪問get和set還是ArrayList更好
- ArrayList對空間的開銷主要體現在總要給尾部預留一定的空間，而LinkedList的開銷主要體現在要爲每個元素佔用較多空間
