概述
（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_ELEMENTDATA的空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