列表對於日常開發來說實在是太常見了，以至於很多開發者習慣性的用到數組，就來一個ArrayList，根本不做過多的思考。其實列表里面還是有很多玩法的，有時候玩不好，搞出來bug還得定位半天。所以這里就再啰嗦一下，整理下相關的內容。
基礎知識
一般計算機相關的專業都應該學過數據結構，而很多的集合都是應用了經典的數據結構設計的。比如數組、棧、隊列、鏈表、樹等等，里面也會用到很多常見的查找或者排序算法，所以就先簡單的回顧下。
數組
數組在c語言里面用的很廣泛，剛開始學習的時候，整天的空指針和數組越界。后來使用java，開始使用一些集合框架，基本都不用擔心這個問題了。
簡單的說，數組就是內存中的一段連續的空間，它對於隨機訪問或者針對某個索引的修改特別快，因為直接可以根據下標索引訪問。不過針對於在指定位置插入節點或者刪除指定位置的元素，會很慢，因為它會導致后面所有的元素都要移動一次空間。
棧
棧是一種先進后出，或者叫做后進先出的數據結構。比如我們在做數學公式計算的時候，就可以用棧保存，並進行相關的計算。另外，在java中棧的應用也很廣，比如程序棧就是通過棧的方式存儲的。
public void a(){ b();}
public void b(){ c();}
public void c(){}
那么在代碼執行的時候，程序棧里面會記錄:
a,b,c
這也是為什么一個方法出錯，錯誤堆棧會打印出一大串的類名和方法名。如果了解這個知識點，對於看懂錯誤日志就很輕松了。
隊列
隊列一般都是特定的業務場景才需要使用，比如某個網站的排隊功能或者是一些叫號功能，都是隊列的機制。
鏈表
鏈表有很多種，有單向鏈表、雙向鏈表、循環鏈表...每個都有不同的使用場景。在java中有一些復雜的集合類，就用到了鏈表，比如HashMap、HashTable、LinkedList等等,這個后面慢慢再說。
Java中的列表
ArrayList
這個是日常開發應用最廣泛的List集合類了，如果不是有特殊要求，基本上這個類就能滿足大部分的需求。不過它還是有很多需要注意的點，比如：
- 非線程安全
- 自動擴容
- 適合場景
非線程安全
這個在javadoc上很明顯的強調過，如果想要線程安全，可以使用Collections.synchronizedList進行包裝，這個synchronizedList其實就是外面套了一層方法，具體的可以參考下面的簡約代碼:
static class SynchronizedList<E> ... {
final Collection<E> c;
final Object mutex;
public boolean add(E e) {
synchronized (mutex) {return c.add(e);}
}
...
}
看到這里應該就了解它的線程安全方法了。
另外也可以使用Vector代替ArrayList，Vector是在方法上做的同步，相對來說要比上面更樂觀一點。
最后還有一些高級的集合，比如CopyOnWriteArrayList，這個就更樂觀了，之后再詳細說。
自動擴容
在添加元素的時候，list會檢查當前的容量是否已經滿：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
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);
}
大致的流程是：
- 先判斷當前容量和插入后的容量大小
- 如果容量不夠，則增加
當前容量*50%，即一半的大小 - 最后把數據增加到末尾
刪除的時候，是直接移動刪除位置以及后面的元素，然后把最后一個元素賦空:
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
modCount
很多的集合類都有一個modCount,在很多新增、修改、刪除的方法中，都會對這個變量modCount++，他有什么作用？
因為很多集合都可以通過iterable來訪問，這時候相當於list的快照，此時是不能修改列表元素的，不然會報錯。這個modCount就是用來判斷是否有修改的。
大概看下代碼:
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
...
int expectedModCount = modCount;
...
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
...
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
適用的場景
因此，ArrayList適合大量隨機讀取和修改的場景，不太適合頻繁刪除和指定位置插入的場景。
LinkedList
LinkedList是基於鏈表的列表，因此具有刪除節點新增節點很快的特性。可以簡單看下它的內部結構：
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
...
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;
}
}
}
通過接口的聲明，可以看出它的幾個特性：
- 可以當作隊列使用Deque,提供push,pop,offer,peek,poll等方法
- 支持序列化，內部使用transient修飾，自定義了序列化和反序列化的方法，節省空間
- 內部是一個靜態內部類的Node節點
靜態內部類和非靜態內部類，有什么不同？1 靜態內部類不需要外部的引用；非靜態內部類需要。2 靜態內部類只能訪問外部類的靜態成員，非靜態內部類則沒有限制。3 靜態內部類可以獨立創建，非靜態內部類總不能。
它的新增和刪除就是簡單的列表操作了，沒什么太要強調的：
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
注意雙向鏈表，在更新的時候是要考慮三個節點的關聯關系的。
刪除的時候比較復雜，如果直接刪除某個對象，則是對比數值進行刪除:
public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
如果是刪除指定的位置，則需要判斷改位置是離first最近，還是last最近，然后分別進行掃描:
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
查詢指定位置的元素:
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;
}
}
移除對應的元素:
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
Vector
Vector根ArrayList很像，只不過他是線程安全的
public synchronized boolean add(E e) {}
public synchronized boolean removeElement(Object obj) {}
...
並且擴容的時候，如果沒有自己設置擴容的步長，就會擴大一倍
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
Stack
這個是繼承於Vector的方法，提供了基本的堆棧功能。同時他也是線程安全的。