// 如果不指定容量（空構(gòu)造器）,則在添加數(shù)據(jù)時(shí)的空構(gòu)造器默認(rèn)初始容量最小為 10
private static final int DEFAULT_CAPACITY = 10;
// 出現(xiàn)在需要用到空數(shù)組的地方，其中一處是使用自定義初始容量構(gòu)造方法時(shí)候如果你指定初始容量為0的時(shí)候，那么elementData指向該數(shù)組
// 另一處是使用包含指定collection集合元素的列表的構(gòu)造方法時(shí)，如果被包含的列表中沒有數(shù)據(jù)，那么elementData指向該數(shù)組
private static final Object[] EMPTY_ELEMENTDATA = {};
// 如果使用默認(rèn)構(gòu)造方法，那么elementData指向該數(shù)組
// 在添加元素時(shí)會判斷是否是使用默認(rèn)構(gòu)造器第一次添加，如果是數(shù)組就會擴(kuò)容至10個(gè)容量
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 默認(rèn)未初始化的儲存 ArrayList集合元素的底層數(shù)組,其長度就是 ArrayList的容量
transient Object[] elementData;
// 私有的elementData數(shù)組中具體的元素對象的數(shù)量,可通過size方法獲得。默認(rèn)初始值為0，在add、remove等方法時(shí)size會改變
private int size;

// 默認(rèn)的構(gòu)造器
public ArrayList() {
	// Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {} 空數(shù)組
	this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 自定義容量大小的構(gòu)造器
public ArrayList(int initialCapacity) {
	if (initialCapacity > 0) {
		this.elementData = new Object[initialCapacity];
	} else if (initialCapacity == 0) {
		this.elementData = EMPTY_ELEMENTDATA;
	} else {
		throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
	}
}

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

// 第一次 add 時(shí)，參數(shù) minCapacity = 1
private void ensureCapacityInternal(int minCapacity) {
	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// calculateCapacity() 方法
private static int calculateCapacity(Object[] elementData, int minCapacity) {	
	// 如果是第一次 add 元素
	if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
		// minCapacity 設(shè)置為 DEFAULT_CAPACITY 與 minCapacity 的最大值
		return Math.max(DEFAULT_CAPACITY, minCapacity);
	}
    return minCapacity;
}
// ensureExplicitCapacity() 方法
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
	// overflow-conscious code
	if (minCapacity - elementData.length > 0)
		grow(minCapacity);
}

private void grow(int minCapacity) {
    // 原容量
    int oldCapacity = elementData.length;
    // 擴(kuò)容后的容量，擴(kuò)大到原容量的 1.5 倍左右，右移一位相當(dāng)于原數(shù)值除以 2 的商
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 如果新容量減去最小容量的值小于 0
    if (newCapacity - minCapacity < 0)
        // 新容量等于最小容量
        newCapacity = minCapacity;
    // 如果新容量減去建議最大容量的值大于 0
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        // 調(diào)整新容量上限或者拋出 OutOfMemoryError
        newCapacity = hugeCapacity(minCapacity);
        
     // 最終進(jìn)行新數(shù)組的構(gòu)建和重新賦值，此后原數(shù)組被摒棄
     // elementData:原數(shù)組; newCapacity:新數(shù)組容量
    elementData = Arrays.copyOf(elementData, newCapacity);
}

public class TestArrayList {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        list.add(8);
        list.add(9);
        list.add(10);
        list.add(11);// 打上斷點(diǎn)
    }
}