ArrayList源码分析

ArrayList

初始化设置：

1、初始化默认容量：10

private static final int DEFAULT_CAPACITY = 10;

2、当往里放置一个Collection集合的时候，此时用这个初始化数组EMPTY_ELEMENTDATA

private static final Object[] EMPTY_ELEMENTDATA = {};

3、如果放置一个，或者一次性放置很多对象的时候，用DEFAULTCAPACITY_EMPTY_ELEMENTDATA这个默认数组存放对象。

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

4、elementData只是对上面的DEFAULTCAPACITY_EMPTY_ELEMENTDATA的复制，因为DEFAULTCAPACITY_EMPTY_ELEMENTDATA是final类型的，不可以被改变，所以需要一个具体的操作数组来操作（elementData），也就是收ArrayList实操的数组是elementData。

transient Object[] elementData;

构造方法：

1、带参数的构造方法

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

2、不带参数的构造方法

public ArrayList() {

        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

}

让当前elementData指向DEFAULTCAPACITY_EMPTY_ELEMENTDATA

3、传Collection对象的构造方法

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

扩容机制：

当容器为 0 的时候，开始添加第一个元素

1、添加一个元素

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 判断当前容器的容量是否够用
        elementData[size++] = e;
        return true;
}

添加之前先要调用 ensureCapacityInternal(size + 1) ， 判断当前容器的容量是否够用。由于当前容器容量为 0 ，所以此时传入size+1，就是要让容器扩容。

2、判断当前容器容量是否够用，是否扩容

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

这个方法其实是判断当前容器的容量是否够用的，如果不够用的话，就要扩容，因为容器的容量不够用的话，那么容器就无法放入下一个对象了。

3、判断容器当前容量是否够用

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

此时，传入的elementData指向DEFAULTCAPACITY_EMPTY_ELEMENTDATA，而且传入的size+1 的大小比默认容量10要小，所以会给ensureExplicitCapacity(）函数返回一个DEFAULT_CAPACITY，就是10。

4、判断是否要扩容

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

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

当前传入的参数是10，由于elementData数组的当前容量是0，所以会调用grow()方法，并把10传进去。

5、扩容

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为0（就是elementData.length，我们之前判断过了嘛），然后根据算法oldCapacity + (oldCapacity >> 1)，新的newCapacity还是0，所以newCapacity - minCapacity是小于0的，所以最终newCapacity为10，然后elementData数组的长度会成为10，OK，这样就扩充完毕了，然后就一路返回add()方法，插入下一个对象就好了。

以上是容器为大小为0的时候，插入第一个对象的时候的执行流程，现在我们来分析一下当容器本身拥有很多元素时，我们插入元素时，ArrayList该怎样扩容。

我们假设容器的大小为10，此时size也为10（容器中有10个对象）：

1. 首先先执行 ensureCapacityInternal(size + 1)，判断一下容器是否需要扩容。同时将11作为参数minCapacity传入到方法中。
2. 然后执行calculateCapacity(elementData, minCapacity)，这
3. elementData已经不指向DEFAULTCAPACITY_EMPTY_ELEMENTDATA了，所以直接返回minCapacity（就是11）
4. ensureExplicitCapacity(int minCapacity)拿到minCapacity（11）之后，此时由于minCapacity（11）的值是要大于elementData.length（10）的，所以此时要扩容，执行grow(int minCapacity) 方法。
5. 由于oldCapacity的大小为10，所以newCapacity的值就为15，然后将原来容器中对象传入到新创建的容器中，然后让elementData指向新的容器当中。OK，扩容完成。

扩容方法：

在ArrayList中，给我们提供了一个扩容方法。

public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
}

注意：这里使用扩容方法的目的是，ArrayList 每次新增元素时都会需要进行容量检测判断，所以当我们清楚知道业务数据量或者需要插入大量元素前，我可以使用 ensureCapacity 来手动增加 ArrayList 实例的容量，以减少递增式再分配的数量。