1. private void ensureCapacityInternal(int minCapacity) {
    2.     if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //调用无参构造时 elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    3.         minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); // 想要的容量为 默认大小和需要扩容量中最大的
    4.     }
    5.     ensureExplicitCapacity(minCapacity);
    6. }
    1. private void ensureExplicitCapacity(int minCapacity) {
    2.     modCount++;
    3.     // overflow-conscious code
    4.     if (minCapacity - elementData.length > 0) //最小容量>数组缓冲区当前长度
    5.         grow(minCapacity);
    6. }
    1. private void grow(int minCapacity) {
    2.     // overflow-conscious code
    3.     int oldCapacity = elementData.length; //获取当前数组的容量
    4.     int newCapacity = oldCapacity + (oldCapacity >> 1);  // 扩容 新的容量=当前容量+当前容量/2.即将当前容量增加一半（当前容量增加1.5倍）。
    5.     if (newCapacity - minCapacity < 0) //如果扩容后的容量还是小于想要的最小容量
    6.         newCapacity = minCapacity;     //将扩容后的容量变为想要的最小容量
    7.     if (newCapacity - MAX_ARRAY_SIZE > 0) //如果扩容后的容量大于临界值，则进行大容量分配
    8.         newCapacity = hugeCapacity(minCapacity);
    9.     // minCapacity is usually close to size, so this is a win:
    10.     elementData = Arrays.copyOf(elementData, newCapacity);
    11. }
    1.     //进行大容量分配
    2.     private static int hugeCapacity(int minCapacity) {
    3.         //如果minCapacity<0，抛出异常   当最小扩容量比Integer.MAX_VALUE大时，会小于0    Integer.MAX_VALUE + 1 < 0
    4.         if (minCapacity < 0) // overflow
    5.             throw new OutOfMemoryError();
    6.         //如果想要的容量大于MAX_ARRAY_SIZE，则分配Integer.MAX_VALUE，否则分配MAX_ARRAY_SIZE    
    7.         return (minCapacity > MAX_ARRAY_SIZE) ?
    8.             Integer.MAX_VALUE :
    9.             MAX_ARRAY_SIZE;        //如果想要的容量大于MAX_ARRAY_SIZE，则分配Integer.MAX_VALUE，否则分配MAX_ARRAY_SIZE
    10.     }
    1. public void add(int index, E element) {
    2.     rangeCheckForAdd(index);
    3.     ensureCapacityInternal(size + 1);  // Increments modCount!!
    4.     System.arraycopy(elementData, index, elementData, index + 1,
    5.                      size - index);
    6.         // 对数组进行复制处理，目的就是空出index的位置插入element，并将index后的元素位移一个位置
    7.         //在插入元素之前，要先将index之后的元素都往后移一位
    8.         //arraycopy(原数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量)
    9.         // 例如add(0,3)操作 [1,2]  -> [1,1,2] -> [3,1,2]  
    10.     elementData[index] = element;
    11.     size++;
    12. }
    1. private void rangeCheckForAdd(int index) {
    2.     if (index > size || index < 0) //判断要操作的数组下标是否越界
    3.         throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    4. }