ArrayList扩容机制的理解

        在Java集合中,作为List接口实现类的ArrayList类,是一种使用较为频繁的集合类型。那么,顾名思义,"Array",说明了该类是基于数组实现的  

//在源码中,说明了底层实现是基于一个Object类型的数组
transient Object[] elementData;

        说到数组,它的特点是长度固定.但是当我们在往ArrayList对象中添加元素时,好像并没有被数组的长度所限制,也没有给它指定长度,如该例子中:

List<String>list=new ArrayList<>();
		list.add("第一");
		list.add("第二");
		list.add("第三");
		list.add("第四");
		list.add("第五");
		list.add("第六");
		System.out.println(list); //[第一, 第二, 第三, 第四, 第五, 第六]

         没有指定长度,而且还在一直添加,这是什么原因呢?那么我们就要从源代码的角度:它的扩容机制说起:

        首先阅读它的无参构造方法:当我们没有对它指定初始容量时,那么它会将一个默认容量的空数组赋给elementData数组。

//无参构造方法,将默认初始化容量的空数组赋给elementData数组 
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

         那么我们容易想到,扩容必会发生在第一次添加元素时。(前提是使用无参构造方法时)当调用add()方法时,会触发扩容机制:

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

        第一行的方法中调用了另外两个方法,目的是执行扩容前一系列的判断操作:

//明确容量
private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

        首先调用calculateCapacity()方法: 传入的参数为size+1(size为数组中元素的个数,而不是长度)并且elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA。第一次添加元素时size+1为1,那么该方法返回较大的DEFAULT_CAPACITY(默认容量为10)。

//The size of the ArrayList (the number of elements it contains)
private int size;

//Default initial capacity.
private static final int DEFAULT_CAPACITY = 10;

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

        然后调用ensureExplicitCapacity()方法:  传入的参数值为10。修改次数+1,此时最小容量为10,数组长度为0,条件成立,执行grow()方法(扩容机制的核心部分)。

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

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

        调用grow()方法: 先将数组长度赋给oldCapacity,新容量的计算为旧容量右移一位,然后再加上旧容量,所以新容量为原容量的1.5倍,这里使用位运算是为了提高运行效率。由于第一个判断条件成立,则新容量为10,也就是说空数组第一次添加元素时,首先扩容为10。最后调用Arrays.copyOf()方法让底层数组指向新容量的,相同内容的新数组完成首次扩容操作。

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

         添加第十一个之前,数组不为默认容量的空数组,则返回的值总是小于或等于10,所以if()条件不会成立,不执行扩容操作。

 if (minCapacity - elementData.length > 0)
            grow(minCapacity);

        当添加第十一个时,11-10>0,执行扩容操作。新容量为10+(10>>1)=15。

        由于不断地扩容会带来一定的系统开销,那么我们一般会预估本次对象的初始化容量为多少,所以就重载了构造方法,创建对象的时候传入一个预估值,那么会根据这个值来创建底层数组。如果参数值为负数,则非法参数值异常。 

        这里请注意: EMPTY_ELEMENTDATA有别DEFAULTCAPACITY_EMPTY_ELEMENTDATA,

前者由于传进的参数是0,则创建一个空数组;后者由于没有指定容量,则为一个待扩容的空数组。

//作用:有参构造方法,可提供预估的容量大小,避免多次扩容带来的系统浪费
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);
        }
    }

         那么,它会无限扩容下去吗?答案当然是不会。我们继续来看源代码: 如果新容量大于一个常量MAX_ARRAY_SIZE,那么会调用hugeCapacity()方法重新计算新容量。

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);

         在所需的最小容量不溢出的情况下,如果大于MAX_ARRAY_SIZE,那么新容量直接等于整形的最大值;如果所需容量小于等于MAX_ARRAY_SIZE那么新容量就为MAX_ARRAY_SIZE。

private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

 以上为我对扩容机制的理解,感谢观看。