private static final long serialVersionUID = 8683452581122892189L;
    /**
     * 默認初始容量大小
     */
    private static final int DEFAULT_CAPACITY = 10;
    /**
     * 空數(shù)組（用于空實例）。
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};
     //用于默認大小空實例的共享空數(shù)組實例。
      //我們把它從EMPTY_ELEMENTDATA數(shù)組中區(qū)分出來，以知道在添加第一個元素時容量需要增加多少。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    /**
     * 存儲ArrayList元素的數(shù)組緩沖區(qū)
     */
    transient Object[] elementData; 
    /**
     * ArrayList 所包含的元素個數(shù)
     */
    private int size;

/**
 *默認構(gòu)造函數(shù)，使用初始容量10構(gòu)造一個空列表(無參數(shù)構(gòu)造)
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * 帶初始容量參數(shù)的構(gòu)造函數(shù)。（用戶自己指定容量）
 */
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {//初始容量大于0
        //創(chuàng)建initialCapacity大小的數(shù)組
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {//初始容量等于0
        //創(chuàng)建空數(shù)組
        this.elementData = EMPTY_ELEMENTDATA;
    } else {//初始容量小于0，拋出異常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

/**
*構(gòu)造包含指定collection元素的列表，這些元素利用該集合的迭代器按順序返回
*如果指定的集合為null，throws NullPointerException。
*/
 public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

public boolean add(E e) {
   ensureCapacityInternal(size + 1);  // size = 0
   elementData[size++] = e;
   return true;
}

private void ensureCapacityInternal(int minCapacity) {//minCapacity = 1
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));//elementData = {}
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //判斷elementData是否為空數(shù)組
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//DEFAULTCAPACITY_EMPTY_ELEMENTDATA =  {}
        return Math.max(DEFAULT_CAPACITY, minCapacity);//DEFAULT_CAPACITY = 10;minCapacity = 1
    }
    return minCapacity;
}

private void ensureCapacityInternal(int minCapacity) {//minCapacity = 1
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));//ensureExplicitCapacity(10)
}

private void ensureExplicitCapacity(int minCapacity) {//minCapacity = 10
    modCount++;
    if (minCapacity - elementData.length > 0)//elementData.length = 0
        grow(minCapacity);
}

private void grow(int minCapacity) {//minCapacity = 10
    int oldCapacity = elementData.length;//oldCapacity = 0
    int newCapacity = oldCapacity + (oldCapacity >> 1);//newCapacity  = 1.5*oldCapacity = 0
    if (newCapacity - minCapacity < 0)//minCapacity = 10
        newCapacity = minCapacity;//newCapacity = 10
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    //利用Arrays.copyOf()方法進行擴容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
     if (minCapacity < 0) // overflow
         throw new OutOfMemoryError();
     return (minCapacity > MAX_ARRAY_SIZE) ?
         Integer.MAX_VALUE :
         MAX_ARRAY_SIZE;
 }