ArrayList扩容机制

ArrayList调用无参构造器创建对象

步骤：

1.调用无参构造器

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

解析：

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

这是一个共享的数组实例，当我们调用无参构造器时，会将它的值赋给elementData，我们可以将它和EMPTY_ELEMENTDATA区分开来，来了解当添加第一个元素时扩容了多少

---

transient Object[] elementData;

被transient修饰，表示该数组不会被序列化。

elementData是储存ArrayList元素的数组缓冲区。

arrayList的容量就是这个数组缓冲区的大小。

任何 elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList在添加第一个元素时都会被扩展成DEFAULT_CAPACITY

2.执行list.add()方法

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

调用arrayList类的add()方法，来添加元素。但在添加元素之前先要保证容量是否足够。

解析：

ensureCapacityInternal(size + 1); 

该方法是确保容器内部容量的方法，只有确保的容器内部容量的大小之后，才可以对数组进行赋值；

size是ArrayList类的一个属性，默认值为0；

size+1是当前所需的最小容量。

 3.执行ensureCapacityInternal(size + 1)方法

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

4.执行calculateCapacity方法

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

该方法用于计算扩充容量的大小，DEFAULTCAPACITY_ELEMENTDATA是ArrayList类的一个常量，它的值是10。

if语句是来辨别elementData数组是否为空，如果是空，就返回DEFAULTCAPACITY_ELEMENTDATA，来给空数组扩容。因为minCapacity此时的值就是传进来的size+1，也就是1。

如果elementData的值不为空就直接返回minCapacity的值，也就是size+1。

 5.执行ensureExplicitCapacity()方法

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

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

解析：

该方法是判断是否需要扩容。

此时minCapacity的值为DEFAULTCAPACITY_ELEMENTDATA的值。

如果此时数组需要的最小容量大于数组的的长度，那么就需要扩容。

6.执行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);
    }

 解析：

该方法是真正实现数组扩容的方法。

oldCapacity存放的是当前数组的容量大小值；

newCapacity存放的是扩容后数组容量大小的值，默认是原数组容量大小的1.5倍的值；

第一个if语句是判断是否是第一次进行扩容，如果是第一次，就直接将当前所需最小容量minCapacity的值赋给newCapacity。

在对newCapacity赋值之后用copyOf方法对elementData按照newCapacity进行扩容。

7.对elementData数组扩容之后再执行add（）方法，对elementData方法进行赋值

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

将传进add方法的值赋给elementData数组，返回ture，就成功的对ArrayList集合添加进的元素。

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

调用有参构造器必须传入一个初始值initalCapacity来作为容器的初始容量。

初始的值必须大于0，如果等于0，就按调用无参构造器的方式赋值。

有参构造器第一次扩容就按1.5倍的方式进行扩容，其他与无参方式一致。