// 将指定元素e加入到elementData数组中
public boolean add(E e) {
    // 检查是否需要扩容，如果需要则执行扩容操作
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 将新元素赋值给底层数组对应的size++的位置
    elementData[size++] = e;
    return true;
}

// 将指定元素添加至指定索引的位置，
// 1. index位置元素及其后所有有效元素（使用size计算）进行复制并从index+1处进行粘贴; 
// 2. 将element设置为index位置的元素；
public void add(int index, E element) {
    // 检查index位置是否越界
    rangeCheckForAdd(index);
    // 检查是否需要扩容，如果需要则执行扩容操作
    ensureCapacityInternal(size + 1);
    // 完成元素的拷贝移动, 如：
    // elementData = [A, B, C, null, null, null, null, null, null, null]
    // add(1, D)
    // elementData = [A, B, B, C, null, null, null, null, null, null]
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    // 将新元素赋值给底层数组对应的索引位置 elementData = [A, D, B, C, null, null, null, null, null, null]
    elementData[index] = element;
    // 有效元素size+1
    size++;
}

// 删除首次匹配到的指定元素
public boolean remove(Object o) {
    // 如果删除的元素是null，则不能使用equal判断，故此处进行分支逻辑处理
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == 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;
}

// 删除指定索引位置的元素
public E remove(int index) {
    // 检查参数索引值是否越界
    rangeCheck(index);
    // 修改次数自增
    modCount++;
    // 获取要删除的元素
    E oldValue = elementData(index);
    // 从index+1处开始复制并在index处进行粘贴
    // 如： elementData=[A, B, C, D]
    // 删除index=1位置的元素B，调用arrayCopy方法后, elementData=[A, C, D, D]
    // 赋值最后一个元素为null，等待gc回收，则 elementData=[A, C, D, null]
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    // size自减，将最后一个元素赋值为null，用于gc该多余元素
    elementData[--size] = null; // clear to let GC do its work
    // 返回被删除元素的引用
    return oldValue;
}

// 内部动态扩容实现
// minCapacity为最小容量，即容纳有效元素所需的容量，add操作时minCapacity为size + 1/numNew
private void ensureCapacityInternal(int minCapacity) {
    // 首次add，底层数据为空数组，则minCapacity为10
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 确认精确的新容量
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // 如果所需的容量大于当前实际容量，则进行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // 当前实际容量
    int oldCapacity = elementData.length;
    // 计算新容量，实际容量 * 1.5，1.5为时间与空间的权衡，扩容太大，则浪费空间，扩容太小，则发生频繁扩容，则耗费性能
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 新的容量比所需的容量小，即：现有容量扩容1.5倍后仍然不够，则使用所需容量进行扩容，当首次添加元素时，新容量为0，所需容量为10，则新容量为10
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 如果新容量大于最大容量，则触发hugeCapacity操作 
    // MAX_ARRAY_SIZE为Integer.MAX_VALUE - 8, -8为防止内存溢出，见源码MAX_ARRAY_SIZE常量注释
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 数组复制，根据新容量大小，进行扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

// java.util.Arrays中的copyOf实现
// 如：original = [0, 1, 2, ...., 9 ] 当前容量oldCapacity=10， 新容量newCapacity=10*1.5=15，则
// 1、创建一个容量为15的新数组copy， elementData = [null, null, null, ...., null]
// 2、将原数组original元素复制到新数组copy中，返回新数组 copy = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, null, null, null, null]
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
       // 开辟新数组，大小为newCapacity
       T[] copy = ((Object)newType == (Object)Object[].class)
           ? (T[]) new Object[newLength]
           : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        // 将已有数组original元素复制到新数组copy中
       System.arraycopy(original, 0, copy, 0,
                        Math.min(original.length, newLength));
       return copy;
}

/**
* 有些虚拟机数组对象中存在8个字节的对象头，所以此处-8目的为减少OOM的可能性
* 如果超过了MAX_ARRAY_SIZE，那么扩容至Integer.MAX_VALUE
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    // 最大扩容Integer.MAX_VALUE，即：整数上限值
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}