【Java】JDK 1.8 ArrayList扩容原理

最新推荐文章于 2023-09-27 07:56:09 发布

csdn_inside

最新推荐文章于 2023-09-27 07:56:09 发布

阅读量512

点赞数 1

分类专栏： Java 文章标签： java arraylist

本文链接：https://blog.csdn.net/csdn_inside/article/details/99603919

版权

Java 专栏收录该内容

11 篇文章 2 订阅

订阅专栏

两个构造器

ArrayList的以下属性，跟扩容有关。

//无参构造时，初始容量大小
private static final int DEFAULT_CAPACITY = 10;
//存放ArrayList元素的数组
transient Object[] elementData;
//ArrayList的大小
private int size;
//传参为0时构造的数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//无参构造时的“空”数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

ArrayList一共有三个构造器，这里主要提到前两个，即无参的和传入一个整数的构造器。

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

无参的很简单，直接将DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋给元素数组。

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

有参的也很简单，传入的参数大于0时，创建一个新的Object数组。等于0时，将EMPTY_ELEMENTDATA赋给元素数组，小于0时，直接抛异常。

这两种方式创建的ArrayList在扩容的时候，会有细微的区别。

以下源码基于JDK 1.8。

使用无参构造器的扩容机制

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

执行add方法，首先会调用ensureCapacityInteral(int minCapacity)方法。

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

这个方法的参数是minCapacity，最小容量，此时minCapacity=size+1=0+1=1。这个方法又会调用ensureExplicitCapacity(int minCapactiy)方法。在这之前会调用calculateCapacity(elementData, minCapacity)方法，利用其返回值。

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

这个方法，传入的参数是elementData和minCapactiy，如果数组是由无参构造器建造的，那么就返回默认数组大小DEFAULT_CAPACITY和当前最小容量minCapacity的较大值。此时minCapacity=1，默认为10，所以返回的是10。

所以，当由无参构造器构造时，如果minCapacity<10，就返回10；大于10，则返回minCapacity，也就是当前容量+1（即size+1）。

而有参构造器构成时，总是返回minCapacity，也即（size+1）。

那么此时ensureExplicitCapacity方法的入参，就是10，

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

由于执行了添加操作，所以modCount++（这个参数在迭代器的hasNext()和next()会用到，可能会抛出ConcurrentModificationException），接着判断minCapacity和当前数组长度的关系，此时minCapacity=10，数组长度为0，minCapacity-element.length>0，所以要执行grow(int 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);
}

oldCapacity=0，newCapacity=oldCapacity*1.5还是=0，所以newCapacity-minCapacity=0-1<0，把newCapacity设置为minCapacity，然后调用Arrays.copyOf方法，将原数组扩容至newCapacity，也就是10。

最后通过elementData[size++] = e，完成添加，此时size=1。

第2次（一直到第10次）添加的时候，还是先调用ensureCapacityInteral(size+1)，此时传入的参数为2。

然后调用calculateCapacity(elementData, minCapacity=2)，2<默认值10，还是返回10。

在ensureExplicitCapacity中，由于此时数组的容量是10，而10-10=0，所以不执行grow方法。

那么直接就是elementData[size++] = e，size=2。

第11次添加的时候，依然调用ensureCapacityInteral(size+1)，此时传入的参数是11。

然后调用calculateCapacity(elementData, minCapacity=11)，11>默认值10，返回11。

在ensureExplicitCapacity中，由于此时数组的容量是10，而11-10>0，所以又要进行扩容了。

grow方法，此时传入的参数是11，oldCapacity是10，newCapacity是15，newCapacity-minCapacity=4>0，直接复制数组，长度由10增加到15，最后完成添加。

此后以此类推。