ArrayList扩容方式的理解

在java中，ArrayList是一个使用非常频繁的集合类型，由名字中含有Array可以简明扼要的得知此集合与数组有关系，它的底层是Object数组，所以它拥有数组的所有特性。
但我们都知道，集合是可以随意增加删除的，而数组的长度是不可变的，那么ArrayList是如何做到基于数组实现集合的特点的呢？又是如何改变ArrayList的大小的呢？这就得提到ArrayList的扩容方式了。

当我们使用无参构造方法创建一个ArrayList对象时，可以根据源码得知：

transient Object[] elementData;

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

在构造方法中，DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值给elementData，而DEFAULTCAPACITY_EMPTY_ELEMENTDATA又是一个空数组，由此可知在使用无参构造方法时，创建的是一个长度为0的空数组。 而当我们使用add方法添加元素时，add方法第一行是执行扩容流程

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

而ensureCapacityInternal方法第一行又会执行calculateCapacity判断最小容量

 private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

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

由于初始elementData是一个空数组，则calculateCapacity return Math.max(DEFAULT_CAPACITY, minCapacity)为10

private static final int DEFAULT_CAPACITY = 10;

 private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

又因为 minCapacity为10，所以执行grow方法

 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);
    }

又因为elementData.length为0，所以oldCapacity为0，因此newCapacity为0,
所以执行 if (newCapacity - minCapacity < 0) newCapacity = minCapacity;}分支得newCapacity为10，最终通过elementData = Arrays.copyOf(elementData, newCapacity);指向一个新的长度为10的数组，达到扩容目的。
在grow方法中，注意int newCapacity = oldCapacity + (oldCapacity >> 1);先将旧容量右移1位，再加上旧容量就得到了新容量，正数右移1位相当于除以2，在该基础上加旧容量，则等价于新容量 = 旧容量 * 1.5，所以才有ArrayList每次扩容为旧容量的1.5倍的说法，最后调用Arrays.copyOf()方法进行拷贝，并将elementData指向新数组，而旧数组因为没有引用指向它，很快就会被垃圾收集器回收掉。当我们第二次执行add方法时，仍然要走到扩容方法，而此时elementData已经不是空数组了
，所以直接返回size+1，即2，接着调用
private void ensureExplicitCapacity(int minCapacity) { modCount++; if (minCapacity - elementData.length > 0) grow(minCapacity); }由于此时minCapacity没有大于数组长度，所以不会进行扩容。但当我们持续调用add方法到第十一次时，minCapacity大于数组长度，则要执行grow方法进行扩容

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);
 }

将原容量右移一位得到5，再加上原来的10得到15，执行 if (newCapacity - minCapacity < 0) newCapacity = minCapacity;最终由上得新容量为15。

当不断扩容，新容量newCapacity大于 MAX_ARRAY_SIZE时

 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

会走向此分支

  if (newCapacity - MAX_ARRAY_SIZE > 0){
            newCapacity = hugeCapacity(minCapacity);
            }
  private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

而hugeCapacity方法会判断minCapacity是否溢出，溢出则抛出 OutOfMemoryError异常,如不溢出，minCapacity大于MAX_ARRAY_SIZE容量即为2147483647，小于容量即为MAX_ARRAY_SIZE。

当我们使用有参构造方法创建一个ArrayList对象时，可以根据源码得知：

 public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

赋予的参数initialCapacity如果大于0，会直接创建一个容量为initialCapacity的数组，等于0时候就等同于无参构造方法，小于0时候会抛出一个 IllegalArgumentException异常。

总结

1.ArrayList每次扩容是原来的1.5倍，因为底层方法是用
int newCapacity = oldCapacity + (oldCapacity >> 1);位运算来进行扩容，因此不用担心奇数扩容进位的问题。
2.数组每次扩容时，elementData = Arrays.copyOf(elementData, newCapacity);会用Arrays工具类将老数组复制到一份新的数组中。
3.代价很高，数组的扩张和复制效率很低，因此我们尽量避免扩容，尽可能预估容量，指定容量，以避免扩容的发生。
4.根据创建的方式不同，容量不同，无参构造方法的初始数组长度是0，当真正执行第一次add方法才分配容量为10private static final int DEFAULT_CAPACITY = 10;，而有参构造方法的容量根据传参决定容量。