新手入门了解ArrayList扩容机制

@Test
  public void testArrayList() {
    //创建一个泛型为String的ArrayList(这里泛型是什么不重要)
    ArrayList<String> list = new ArrayList<String>();
    //依次添加11个元素
    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");
  }

private static final int DEFAULT_CAPACITY = 10;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
private int size;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

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

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

private static int calculateCapacity(Object[] elementData, int minCapacity) {　　　　//若传入的是个空数组，则返回的是最小容量 是 默认容量（10） 和 当前最小容量（0）之间的最大值
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
      return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
  }

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;
    //将旧数组大小+旧数组/2，即旧数组的1.5倍是新数组的大小（先不要在意>>1的意思，你只要知道oldCapacity >> 1表示oldCapacity/2就行）
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //如果扩容后的是数组大小还是小于最小所需容量，直接让minCapacity赋值到新容量
    if (newCapacity - minCapacity < 0)
      newCapacity = minCapacity;
    //若新容量大小大于数组长度的最大预设值；由于扩容后是原数组的1.5倍，则非常有可能会溢出这个预设值
    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) {
    //若最小容量小于0的情况，抛出异常
    if (minCapacity < 0) // overflow
      throw new OutOfMemoryError();
    //若最小容量>最大预设值，返回Integer.Max_VALUE,否则是MAX_ARRAY_SIZE（Integer.Max_VALUE-8）
    return (minCapacity > MAX_ARRAY_SIZE) ?
      Integer.MAX_VALUE :
      MAX_ARRAY_SIZE;
  }