Java ArrayList扩容底层原理深挖

今儿咱来看看ArrayList是怎么扩容的，底层是什么样的

先说结论

1.利用空参构造创建集合时，在底层创建一个默认长度为0的数组。
2.添加第一个元素时，底层会创建一个新的长度为10的数组，要是存不下，就创建一个能正好存下的数组。
3.这个数组存满时，会扩容1.5倍创建新数组，并把旧数组拷贝到新数组中。
4.如果一次添加多个元素，1.5倍还放不下，则新创建的数组的长度以实际为准，并把旧数组拷贝到新数组中。

首先咱先看看空参构造

ArrayList<Integer> al = new ArrayList<>();

//底层源码

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

Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData;

elementData是集合中存储对象的数组

DEFAULTCAPACITY_EMPTY_ELEMENTDATA这玩意是一个对象的空数组

然后往里面添加元素

al.add(5);


//底层源码

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

private void ensureCapacityInternal(int minCapacity) {//size+1当作最小容量
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

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

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

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

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

public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

这是全部的底层代码，我们分开一点一点看

 

 

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

size是记录集合中元素个数的成员变量

调用了ensureCapacityInternal方法，传入size+1，

让下一个数组元素等于添加的对象，返回添加成功

 

private void ensureCapacityInternal(int minCapacity) {//size+1当作最小容量
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

calculateCapacity：用在计算数组的容量，它的参数是一个对象数组和一个最小需要的容量。

ensureExplicitCapacity：用在数组容量不足时扩充数组的大小，它的参数是最小需要的容量。

 

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

private static final int DEFAULT_CAPACITY = 10;

DEFAULTCAPACITY_EMPTY_ELEMENTDATA这个常量数组是在ArrayList类中定义的，用于表示一个空的ArrayList。

如果是空的，就返回默认容量(就是10)和最小需要的容量中较大的一个，即Math.max(DEFAULT_CAPACITY, minCapacity)。

人话就是如果集合为空，那就看看所需最小容量和默认容量哪个大，如果默认大就返回10，开辟一个长度为10的数组，如果所需最小容量大，就返回所需最小容量，开辟一个长度为所需最小容量的数组。

那为什么会出现所需最小容量大于默认容量呢？

答案是因为有一个addAll方法可以批量添加数据。

 

 

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

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

modCount++，如果所需最小长度大于这个它本身的长度，那就进行扩容。

 

 

 

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 + (oldCapacity >> 1)。这里使用了右移运算符>>，相当于除以2。

然后判断新的容量是否大于等于最小需要的容量，如果不是，就把新的容量设为最小需要的容量。
接着判断新的容量是否超过了数组的最大限制，即MAX_ARRAY_SIZE。如果是，就调用一个叫hugeCapacity的方法，来返回一个合适的容量。

最后，使用Arrays.copyOf方法，把原来的数组复制到一个新的数组中，并把新的数组赋值给elementData。

 

总结一下吧，ArrayList扩容底层大概分为四步：

1.利用空参构造创建集合时，在底层创建一个默认长度为0的数组。
2.添加第一个元素时，底层会创建一个新的长度为10的数组，要是存不下，就创建一个能正好存下的数组。
3.这个数组存满时，会扩容1.5倍创建新数组，并把旧数组拷贝到新数组中。
4.如果一次添加多个元素，1.5倍还放不下，则新创建的数组的长度以实际为准，并把旧数组拷贝到新数组中。