概述
（1）ArrayList 是一種變長的集合類，基於定長陣列實現。
（2）ArrayList 允許空值和重複元素，新增元素時，會擴容機制生成一個更大的陣列。
（3）可以保證在 O(1) 複雜度下完成隨機查詢操作。
（4）ArrayList 是非執行緒安全類。
為追求效率，ArrayList沒有實現同步（synchronized），如果需要多個執行緒併發訪問，使用者可以手動同步，也可使用Vector替代。
類的屬性
/**
* 預設初始容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 共享的空陣列例項，用於空例項
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
*ArrayList 實際資料儲存的一個陣列
*儲存ArrayList的元素的陣列緩衝區。 ArrayList的容量是此陣列緩衝區的長度。
*新增第一個元素時，任何具有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDA他的空ArrayList都將擴充套件為DEFAULT_CAPACITY。
Object[]陣列，也就是說該陣列可以放任何物件（所有物件都繼承自父類Object）
*/
transient Object[] elementData;
/**
* 共享的空陣列例項，用於預設大小的空例項
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* elementData 的大小，size是邏輯長度，並不是陣列長度。
*/
private int size;
//很有意思，下面介紹
protected transient int modCount = 0;
static修飾的變數，常駐於方法區，我們不需要new，JVM會提前給我們初始化好，這個特性在實際開發過程中，經常拿來做快取。
ArrayList new的時候考慮了快取，為了避免我們反覆的建立無用陣列，所有新new出來的ArrayList底層陣列都指向快取在方法區裡的Object[]陣列。
構造方法
//引數為初始化容量
public ArrayList(int initialCapacity) {
//判斷容量的合法性
if (initialCapacity > 0) {
//elementData才是實際存放元素的陣列
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//如果傳遞的長度為0，就是直接使用自己已經定義的成員變數(一個空陣列)
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
//無參構造，使用預設的size為10的空陣列，在構造方法中沒有對陣列長度進行設定，會在後續呼叫add方法的時候進行擴容
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//將一個引數為Collection的集合轉變為ArrayList（實際上就是將集合中的元素換為了陣列的形式）。
//傳入的集合為null會丟擲空指標異常（呼叫c.toArray()方法的時候）
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
//c.toArray()可能不會正確地返回一個 Object[]陣列，那麼使用Arrays.copyOf()方法
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
//如果集合轉換為陣列之後陣列長度為0，就直接使用自己的空成員變數初始化elementData
this.elementData = EMPTY_ELEMENTDATA;
}
}
圖解析：例如 List
當新增元素後，elementData 指向 elementData[10]（DEFAULT_CAPACITY = 10），size 是邏輯長度，加一。
add，grow以及工具類底層分析
public boolean add(E e) {
//因為要新增元素，所以新增之後可能導致容量不夠，所以需要在新增之前進行判斷（擴容）
ensureCapacityInternal(size + 1);
// Increments modCount!!待會會介紹到fast-fail!!
//但是這個擴容的方法裡面呼叫了。add（）方法就不用呼叫了。其實是呼叫過了的,modCount 已經加了1。
//值e放到相應的elementData[]下標的陣列裡面
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//如果底層陣列就是預設的快取陣列，取兩個引數的大的一個值繼續往下呼叫
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//這裡就是判斷elementData陣列是不是為空陣列
//（使用的無參構造的時候，elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA）
//如果是，那麼比較size+1(第一次呼叫add的時候size+1=1)和DEFAULT_CAPACITY，
//那麼顯然容量為10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
//記錄修改次數
modCount++;
//溢位
//如果傳過來的值大於底層陣列的長度，繼續grow方法。
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// oldCapacity為舊陣列的容量
int oldCapacity = elementData.length;
// newCapacity為新陣列的容量（oldCap+oldCap/2:即更新為舊容量的1.5倍）
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 檢查新容量的大小是否小於最小需要容量，如果小於那舊將最小容量最為陣列的新容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//如果新容量大於MAX_ARRAY_SIZE，使用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 final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
@Native public static final int MAX_VALUE = 0x7fffffff;
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
//對minCapacity和MAX_ARRAY_SIZE進行比較
//若minCapacity大，將Integer.MAX_VALUE作為新陣列的大小
//若MAX_ARRAY_SIZE大，將MAX_ARRAY_SIZE作為新陣列的大小
//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
//工具類
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
//System.arraycopy()方法,native方法，所以直接只用這個方法會獲得很高的效能
//這個也是具體的擴容的具體底層實現
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
//src:源陣列
//srcPos:從源陣列的srcPos位置處開始移動
//dest:目標陣列
//desPos:源陣列的srcPos位置處開始移動的元素，這些元素從目標陣列的desPos處開始填充
//length:移動源陣列的長度
擴容：newCapacity為新陣列的容量（oldCap+oldCap/2:即更新為舊容量的1.5倍）
remove方法分析
1、remove(int index) 按照下標刪除
public E remove(int index) {
rangeCheck(index); //校驗下標是否合法（如果index>size，舊丟擲IndexOutOfBoundsException異常）
modCount++;//修改list結構，就需要更新這個值
E oldValue = elementData(index); //直接在陣列中查詢這個值
int numMoved = size - index - 1;//這裡計算所需要移動的數目
//如果這個值大於0 說明後續有元素需要左移(size=index+1)
//如果是0說明被移除的物件就是最後一位元素(不需要移動別的元素)
if (numMoved > 0)
//索引index只有的所有元素左移一位 覆蓋掉index位置上的元素
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//移動之後，原陣列中size位置null
elementData[--size] = null; // clear to let GC do its work
//返回舊值
return oldValue;
}
2、remove(Object o) 按照元素刪除，會刪除和引數匹配的第一個元素
public boolean remove(Object o) {
//如果元素是null 遍歷陣列移除第一個null
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
//遍歷找到第一個null元素的下標 呼叫下標移除元素的方法
fastRemove(index);
return true;
}
} else {
//找到元素對應的下標 呼叫下標移除元素的方法
for (int index = 0; index < size; index++)
//要用equals
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
//按照下標移除元素（通過陣列元素的位置移動來達到刪除的效果）
private void fastRemove(int index) {
modCount++;
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
}
fail-fast
在系統設計中，快速失效系統一種可以立即報告任何可能表明故障的情況的系統。
快速失效系統通常設計用於停止正常操作，而不是試圖繼續可能存在缺陷的過程。
這種設計通常會在操作中的多個點檢查系統的狀態，因此可以及早檢測到任何故障。
快速失敗模組的職責是檢測錯誤，然後讓系統的下一個最高階別處理錯誤。
在Java集合類中很多地方都用到了該機制進行設計，一旦使用不當，觸發fail-fast機制設計的程式碼，就會發生非預期情況。
我們通常說的Java中的fail-fast機制，預設指的是Java集合的一種錯誤檢測機制。
當多個執行緒對部分集合進行結構上的改變的操作時，有可能會觸發該機制時，之後就會丟擲併發修改異常ConcurrentModificationException.
然如果不在多執行緒環境下，如果在foreach遍歷的時候使用add/remove方法，也可能會丟擲該異常。
public boolean add(E e) {
ensureCapacityInternal(size + 1);
// Increments modCount!!待會會介紹到fast-fail!!
//但是這個擴容的方法裡面呼叫了。add（）方法就不用呼叫了。其實是呼叫過了的,modCount 已經加了1。
elementData[size++] = e;
return true;
}
Arraylist與Vector的區別
用得比較少了。
public class Vector<E>
extends AbstractList<E>
//實現List介面
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//底層陣列實現
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
Vector原始碼分析
//宣告瞭同步得關鍵字
public synchronized boolean add(E e) {
modCount++;
//檢查是否擴容
ensureCapacityHelper(elementCount + 1);
//賦值
elementData[elementCount++] = e;
return true;
}
無一例外，只要是關鍵性的操作，方法前面都加了synchronized關鍵字，來保證執行緒的安全性。
不同點：擴容後是舊容量的倆倍。
參考連結
https://juejin.cn/post/6844903904346374158