public boolean add(E e) {
    // 确保内部容量足够，这里传递的最小容量是当前大小加1
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 添加元素
    elementData[size++] = e;
    return true;
}

public void add(int index, E element) {
    // 检查插入的下标是否满足要求，不能小于0和大于当前的size
    rangeCheckForAdd(index);

    // 确保容量足够
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 进行数组拷贝
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 添加元素
    elementData[index] = element;
    // size自增
    size++;
}

private void ensureCapacityInternal(int minCapacity) {
    // 如果调用的是无参构造器来初始话的，那么elementData就是EMPTY_ELEMENTDATA；如果是有参构造器，则不是。
    if (elementData == EMPTY_ELEMENTDATA) {
        // 确保首次扩容的大小不会小于默认的容量，默认容量大小为10。
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    // 保证容量需要达到minCapacity
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    // 修改次数自增
    modCount++;

    // overflow-conscious code
    // 如果所需要的大小超过了当前已有的大小，
    if (minCapacity - elementData.length > 0)
        // 则进行扩容
        grow(minCapacity);
}

/**
 * Default initial capacity.
 */
// 默认初始容量
private static final int DEFAULT_CAPACITY = 10;

/**
 * Shared empty array instance used for empty instances.
 */
// 空数组对象
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == EMPTY_ELEMENTDATA will be expanded to
 * DEFAULT_CAPACITY when the first element is added.
 */
// 保存元素的数组
transient Object[] elementData; // non-private to simplify nested class access

/**
 * The size of the ArrayList (the number of elements it contains).
 *
 * @serial
 */
// 实际的元素的个数，注意和elementData.length进行区分，后者是大于等于size的
private int size;

/**
 * Constructs an empty list with the specified initial capacity.
 *
 * @param  initialCapacity  the initial capacity of the list
 * @throws IllegalArgumentException if the specified initial capacity
 *         is negative
 */
public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    // 直接创建指定容量的数组
    this.elementData = new Object[initialCapacity];
}

/**
 * Constructs an empty list with an initial capacity of ten.
 */
public ArrayList() {
    super();
    // 将标记数组赋值给数组对象
    this.elementData = EMPTY_ELEMENTDATA;
}

/**
 * Constructs a list containing the elements of the specified
 * collection, in the order they are returned by the collection's
 * iterator.
 *
 * @param c the collection whose elements are to be placed into this list
 * @throws NullPointerException if the specified collection is null
 */
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        // 拷贝数组
        elementData = Arrays.copyOf(elementData, size, Object[].class);
}

/**
 * The maximum size of array to allocate.
 * Some VMs reserve some header words in an array.
 * Attempts to allocate larger arrays may result in
 * OutOfMemoryError: Requested array size exceeds VM limit
 */
/*
 * 为什么这里是 Integer.MAX_VALUE - 8 ？
 * 上面的英文注释说明了是为了��数组对象的头留一些空间。
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 新容量是旧容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 如果1.5倍就容量还是小于了所需大小，
    if (newCapacity - minCapacity < 0)
        // 则直接等于所需大小
        newCapacity = minCapacity;
    // 如果新容量超过了最大的数组大小，
    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 int hugeCapacity(int minCapacity) {
    // 如果容量值为负，说明已经溢出了。
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    /*
     * 如果所需容量值大于了最大数组大小，则直接等于Interger的最大值；
     * 否则就是最大数组大小，因为此时1.5倍的旧容量已经大于了最大数组大小，这里直接扩容到最大数组大小，也无可厚非。
     */
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

public static <T> void testBadRemove(ArrayList<T> list) {
    for (T i : list) {
        // 问题1: 会抛出ConcurrentModificationException这个异常
        list.remove(i);
    }
}

public Iterator<E> iterator() {
    // 创建ArrayList内部的迭代器实现
    return new Itr();
}

// 下一个需要返回的元素的下标
int cursor;       // index of next element to return
// 上次返回元素的下标
int lastRet = -1; // index of last element returned; -1 if no such
// 记录当前ArrayList的修改次数，目的是为了检测迭代过程中的并发修改。
int expectedModCount = modCount;

@SuppressWarnings("unchecked")
public E next() {
    // 检测并发修改
    checkForComodification();
    int i = cursor;
    // 如果需要返回的元素的下标超出了容量，
    if (i >= size)
        // 则抛出异常
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    cursor = i + 1;
    // 返回目标元素
    return (E) elementData[lastRet = i];
}

final void checkForComodification() {
    /*
     * 如果内部的修改次数不等于外部的修改次数，
     * 也就是说在迭代的过程中使用了当前迭代器外部的方法对ArrayList进行了修改，
     * 那么会破坏当前迭代器内的字段，比如cursor和lastRet，会导致当前迭代器的操作出现歧义，所以这里会直接并发修改异常。
     */
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

public E remove(int index) {
    rangeCheck(index);

    // 修改次数自增
    modCount++;
    // 获取待删除元素
    E oldValue = elementData(index);

    // 计算需要移动的元素
    int numMoved = size - index - 1;
    if (numMoved > 0)
        // 数组拷贝，让目标元素后面的那些元素依次往前挪动一个位置
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 因为此时 size - 2 和 size -1 指向的是同一个对象，所以不需要保留多余的引用了；或者说 size - 1 就是待删除的元素。
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

public static void testGoodRemove(ArrayList<Integer> list) {
    /*
     * 如果是在是要在遍历中移除元素，要么通过迭代器的remove方法。
     * 要么只调用ArrayList的remove方法，而不要直接或间接地调用到迭代器的方法。
     */
    Iterator<Integer> itr = list.iterator();
    while (itr.hasNext()) {
        Integer next = itr.next();
        /*
         * 通过调用迭代器的remove方法，可以正常删除元素。
         * 问题2: 注意，如果不调用next方法，直接调用remove方法，仍然是会抛出IllegalStateException异常的。
         */
        itr.remove();
    }
}

public void remove() {
    /*
     * 如果没有调用过next方法，直接抛出异常。
     * 为什么这里要检查lastRet要小于0？
     * 因为该方法的设计目的就是删除上次访问过的元素，所以下面调用ArrayList的remove方法时传入的是lastRet。
     * 如果lastRet小于0，肯定是非法下标不能进行删除操作。
     */
    if (lastRet < 0)
        throw new IllegalStateException();
    // 检查并发修改
    checkForComodification();

    try {
        // 调用外部的ArrayList的remove方法
        ArrayList.this.remove(lastRet);
        // 因为删掉的元素原先的位置被它后面一个元素占据了，所以让
        cursor = lastRet;
        // 重置lastRet
        lastRet = -1;
        // 同步内外的两个修改次数变量，这样在并发修改检查时不会抛出异常。
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

public static <T> void testGoodRemove_2(ArrayList<T> list) {
    while(!list.isEmpty()) {
        /*
         * 两种方式都可以，第一种是从前删到尾；第二种是从尾删到前。
         */
        // list.remove(0);
        list.remove(list.size() - 1);
    }
}

public static <T> void testBadRemove_2(ArrayList<T> list) {
    /*
     * 注意这种代码看似没有��题，其实只能删除前一半的元素。
     * 因为i和list.size()都在变动，这本身在语法上没有错误，但是在逻辑上是有问题的。
     */
    for (int i = 0; i < list.size(); i++) {
        list.remove(i);
    }
    // 结束结果为: list的原始容量 / 2
    System.out.println(list.size());
}