阅读ArrayList的动态扩容源码

ArrayList可以理解成一种“会自动扩增容量的Array”。那么问题来了,ArrayList是如何扩容的

首先打开ArrayList源码,我本地是Java 1.8版本。针对最初的问题,可以翻到add(E e) 方法:

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
   // 注意这里的size表示ArrayList的长度,而非Array(数组)的长度。

源码的内容真的非常的简单,可以看到扩容的处理在ensureCapacityInternal方法中处理的:

 private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
    //这里的elementData是存储数据的对象,ArrayList实际上是对数组的一层封装。
    //注意minCapacity这里确定了最小值DEFAULT_CAPACITY,也就是10

ensureCapacityInternal方法又是一层神秘的面纱,继续掀。


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

咦,终于看到庐山真面目——grow(int minCapacity)方法。首先我们确认下minCapacity的值是多少。看下 add(E e)方法中有这么一行:

 ensureCapacityInternal(size + 1)

由此可见输入值minCapacity的值为size+1。在ensureCapacityInternal确定了minCapacity的最小值10。接下来看下 grow(int minCapacity) 方法中的这两行:

int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);

假设数组的初始化方法调用的是无参的new ArrayList(),这两行代码处理的逻辑就是:

oldCapacity = 0, newCapacity = 0 + 0000>>1 = 0 + 0000 = 0;
oldCapacity = 1, newCapacity = 1 + 0001>>1 = 1 + 0000 = 1;
oldCapacity = 2, newCapacity = 2 + 0010>>1 = 2 + 0001 = 3;
oldCapacity = 4, newCapacity = 4 + 0100>>1 = 4 + 0010 = 6;
oldCapacity = 7, newCapacity = 7 + 0111>>1 = 7 + 0011 = 10;
oldCapacity = 11, newCapacity = 11 + 1011>>1 = 11 + 0101 = 16;
oldCapacity = 17, newCapacity = 17 + 1 0001>>1 = 17 + 1000 = 25;
...

就算不理解位运算,也能归纳出来,newCapacity是oldCapacity的1.5倍。也就是说:每次执行完add(E e)方法,数组的容量大小都会扩大为原来的1.5倍

其他方法的阅读:
addAll(Collection c)

    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

与add(E e) 的步骤一直,先数组扩容,再合并数组。
扩容基本逻辑:newCapacity会先扩大为原来的1.5倍,再和【 数组当前容量+新增大小容量】进行比较,取较大的值进行扩容。

add(int index,E element)

    public void add(int index, E element) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

这个方法主要完成数组的拷贝:先将【 第index位 至 末位】数组往后位移一位,然后在将element赋值给index位。

这个问题还是去年遇到的一道面试题,很惭愧当时没有回答上来。作为一件耿耿于怀的心病,今天总算时弄清楚扩容的步骤。希望自己未来能够收获更多有趣的知识。

你可能感兴趣的:(java,ArrayList,数组扩容,java,arraylist)