ArrayList 扩容方式以及扩容机制

废话少说，先上源码：

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

根据意思可以看出ensureCapacityInternal()是用来扩容的，形参为最小扩容量，进入此方法后：

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

如果传入的是个空数组则最小容量取默认容量与minCapacity之间的最大值,默认容量是10

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

增加扩容次数，如果最小需要空间比elementData的内存空间要大，则需要扩容

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        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);
    }

获取到ArrayList中elementData数组的内存空间长度,
扩容至原来的1.5倍
判断一下新数组的容量够不够，不够则为需要的长度
判断溢出
调用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;
    }

判断溢出方法，扩展数量为负数直接溢出error,

各种疑问：

1. 为什么数组长度的最大值是Integer.MAX_VALUE - 8
   数组作为一个对象，需要一定的内存存储对象头信息，对象头信息最大占用内存不可超过8字节。
   https://www.ibm.com/developerworks/java/library/j-codetoheap/index.html
   https://stackoverflow.com/questions/35756277/why-the-maximum-array-size-of-arraylist-is-integer-max-value-8
2. Arrays.copyOf()方法

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

https://blog.csdn.net/balsamspear/article/details/85078599
https://blog.csdn.net/balsamspear/article/details/85069207