ArrayList扩容方式

ArrayList是一个可以动态修改的数组，与普通数组的区别就是它没有固定大小的限制，我们可以添加和删除元素。ArrayList继承了AbstractList，并实现了List接口。

1、成员变量

 private static final int DEFAULT_CAPACITY = 10;

常量，表示默认的容量大小，在没有初始化容量大小时调用add()方法后初始化的容量大小

private static final Object[] EMPTY_ELEMENTDATA = {};

  定义一个空数组，数组的大小为0

 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

 定义一个默认空容量的数组，大小为0，在使用AsList方法时它可以变为任意的大小

 transient Object[] elementData; 

ArrayList内部实际用于存储元素的数组，并且不可以被序列化

 private int size;

表示数组元素的个数

2、构造方法

（1）无参构造方法
     在直接创建ArrayList时，一个默认的空数组赋值给elementData,并且这个数组用final关键字修饰。
     在调用add()方法添加元素时，会使用到无参构造方法，将DEFAULT_CAPACITY分配给elementData。

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

（2） 有参构造方法
    传入的int型参数表示数组容量的大小，跟据传入参数的大小创建对应容量的数组
    当initialCapacity>0时，会在堆区创建一个大小为initialCapacity的数组，用来保存传入的数据，然后将其赋给elementData,此时数组的容量为initialCapacity，元素的个数为默认值0
    当initialCapacity=0时，elementData被赋予空数组，空数组的修饰符为final，所以ArrayList容量为0，元素个数为0
    当initialCapacity<0时，会抛出异常，因为数组大小不能小于0

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

（3） 带有Collection对象参数的构造方法
     在传入Collection后首先会将其转换为数组，存入elementData
     更新size的值，同时判断size的大小，如果是size等于0，直接将空对象EMPTY_ELEMENTDATA赋给elementData
     如果size的值大于0，则执行Arrays.copy方法，把collection对象的内容copy到elementData中。

 public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

3、扩容

在使用add()方法时，它在方法内部调用了ensureCapacityInternal方法

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

在ensureCapacityInternal里又调用了ensureExplicitCapacity和calculateCapacity

calculateCapacity方法是用来判断elementData是否为空数组，如果是，返回DEFAULT_CAPACITY和minCapacity的最大值，否则返回minCapacity.

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

ensureExplicitCapacity方法用来判断minCapacity的数组长度，如果minCapacity大于数组长度时会调用grow()方法进行扩容。

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

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

oldCapacity是旧数组的容量，旧数组的容量等于数组长度，newCapacity是扩容后新数组的容量，新数组的容量等于旧数组的容量+旧数组容量的一半。

判断新的容量和旧容量的大小关系，如果新的容量小于最小需要量，新容量等于最小需要量minCapacity.

判断当前容量是否大于MAX_ARRAY_SIZE，用hugeCapacity()方法。

将原来的数组拷贝进新的数组中。

MAX_ARRAY_SIZE表示的是一个常量，是要分配的数组的最大容量

hugeCapacity()方法是比较minCapacity和MAX_ARRAY_SIZE的大小，如果minCapacity小于0,抛出异常，如果minCapacity大于MAX_ARRAY_SIZE，返回Integer.MAX.VALUE,否则，返回MAX_ARRAY_SIZE。

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

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

为什么要选择1.5倍进行扩容

扩容因子的大小选择，需要考虑如下情况：

扩容容量不能太小，防止频繁扩容，频繁申请内存空间 + 数组频繁复制

扩容容量不能太大，需要充分利用空间，避免浪费过多空间；

为了能充分使用之前分配的内存空间，最好把增长因子设为 1<k<2.

k=1.5时，就能充分利用前面已经释放的空间。如果k >= 2，新容量刚刚好永远大于过去所有废弃的数组容量

并且充分利用移位操作（右移一位），减少浮点数或者运算时间和运算次数。