ArrayList及其扩容机制

ArrayList的底层的数据结构实际是Object数组，封装了丰富的数组操作（增删改查）

本篇文章对ArrayList的讲解将重点从构造方法和add方法（扩容机制JDK8版）方面入手

1、构造方法

ArrayList有三个构造方法，如图：

//参数为决定ArrayList初始容量的构造方法
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);
        }
    }
l

 //无参构造方法
 public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

 //参数为指定集合元素的列表的构造方法
 public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

另外ArrayList定义的部分变量如下：

    //默认初始容量大小
    private static final int DEFAULT_CAPACITY = 10;

    //空数组（用于空实例）
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //用于默认大小空实例的共享空数组实例。
    //我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //保存ArrayList数据的数组
    transient Object[] elementData; 

    //ArrayList 所包含的元素个数
    private int size;

通过观察变量可以发现，ArrayList中定义了两个空数组

DEFAULT_CAPACITY   和    DEFAULTCAPACITY_EMPTY_ELEMENTDATA

其中在两个有参构造方法中，当传入参数为0（表示创建容量为0的ArrayList）或者传入参数集合元素数为0时，构造方法给elementData赋的值是DEFAULT_CAPACITY

而无参构造方法中赋的值是DEFAULTCAPACITY_EMPTY_ELEMENTDATA

这样做的目的我所认识的是为了后面扩容过程中区分ArrayList是通过无参构造的还是通过其他构造方法构造，这句话一开始我是无法理解的，等到我查看add方法的源码之后有些理解了。

其中结合以上问题我又开始思考：

通过无参构造方法的ArrayList和通过传入参数为0的构造方法的ArrayList（指定初始容量为0的ArrayList）

        //使用无参构造方法
        ArrayList<String> arrayList1=new ArrayList<>();
        //使用指定容量参数的构造方法
        ArrayList<String> arrayList2=new ArrayList<>(0);

他们的第一次扩容是否有差异

2、add方法

        常用的add(E e)方法，当调用add方法添加一个元素时，方法先调用ensureCapacityInternal方法确保容量足够，如发现不足该方法将调用grow方法进行扩容

/**
* 将指定的元素追加到此列表的末尾。
*/
public boolean add(E e) {
    // 加元素之前，先调用ensureCapacityInternal方法
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 这里看到ArrayList添加元素的实质就相当于为数组赋值
    elementData[size++] = e;
    return true;
}

 （1）ensureCapacityInternal方法

        方法中就一条语句，调用 ensureExplicitCapacity方法，传入的参数为调用calculateCapacity(elementData, minCapacity)的返回值

        calculateCapacity方法中个人认为解答了为什么需要定义两个空对象，如果为无参构造的且还未赋值将进入判断语句，将返回10。而其他构造方法构造的将返回size+1。

// 根据给定的最小容量和当前数组元素来计算所需容量。
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 如果当前数组元素为空数组（初始情况），返回默认容量和最小容量中的较大值作为所需容量
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 否则直接返回最小容量
    return minCapacity;
}

// 确保内部容量达到指定的最小容量。
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

 （2）ensureExplicitCapacity方法

         如何需要的容量（minCapacity）大于elementData目前的最大容量，即无法再添加新元素将进行扩容调用grow方法，否则无需扩容，结束ensureCapacityInternal方法。

//判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    //判断当前数组容量是否足以存储minCapacity个元素
    if (minCapacity - elementData.length > 0)
        //调用grow方法进行扩容
        grow(minCapacity);
}

 （3）grow方法

        方法中有两个变量，其中newCapacity变量后面决定扩容的容量

        grow方法重点在一个扩容公式和两个判断

        一个扩容公式： oldCapacity + (oldCapacity >> 1)  

        值得注意的是JDK1.6以下的时候扩容公式为： （值*3）/ 2 +1

        两个判断：

        第一个是判断是 扩容公式得出的预计容量 和 本次添加元素需要满足的最小容量 的比较，前者更小则进入判断语句，newCapacity的值变为minCapacity。

        第二个判断是newCapacity是否超出MAX_ARRAY_SIZE的值，超出将newCapacity的值变为Integer.MAX_VALUE

/**
 * 要分配的最大数组大小
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * ArrayList扩容的核心方法。
 */
private void grow(int minCapacity) {
    // oldCapacity为旧容量，newCapacity为新容量
    int oldCapacity = elementData.length;
    // 将oldCapacity 右移一位，其效果相当于oldCapacity /2，
    // 我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
    int newCapacity = oldCapacity + (oldCapacity >> 1);

    // 然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

    // 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
    // 如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
    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);
}

  3、扩容差异

        了解了源码后，可以发现无参方式添加第一个元素的后的容量是10，而有参构造初始容量为0的ArrayList添加第一个元素后的容量是1.

        随后我开始编个java小程序，进行实验证明，代码如下：

public class Main {
    public static void main(String[] args) throws Exception {
        //使用无参构造方法
        ArrayList<String> arrayList1=new ArrayList<>();
        //使用指定容量参数的构造方法
        ArrayList<String> arrayList2=new ArrayList<>(0);

        System.out.println("arrayList1初始容量："+len(arrayList1));
        System.out.println("arrayList2初始容量："+len(arrayList2));

        //第一次分别加入元素
        arrayList1.add("hello");
        arrayList2.add("hello");

        System.out.println("arrayList1加入第一个元素后的容量："+len(arrayList1));
        System.out.println("arrayList2加入第一个元素后的容量："+len(arrayList2));

        //第二次分别加入元素
        arrayList1.add("hello");
        arrayList2.add("hello");

        System.out.println("arrayList1加入第二个元素后的容量："+len(arrayList1));
        System.out.println("arrayList1加入第二个元素后的容量："+len(arrayList2));

    }

    //查看ArrayList集合容量(利用反射）
    public static int len(ArrayList list) throws Exception{
        //获取Class对象
        Class c = Class.forName("java.util.ArrayList");
        //映射Class对象c所表示类(即Arraylist)的属性
        Field field = c.getDeclaredField("elementData");
        //设置访问状态表示为true
        field.setAccessible(true);
        //返回指定对象上此 Field 表示的字段的值
        Object[] object = (Object[])field.get(list);
        return object.length;
    }


}

        实验结果：

arrayList1初始容量：0
arrayList2初始容量：0
arrayList1加入第一个元素后的容量：10
arrayList2加入第一个元素后的容量：1
arrayList1加入第二个元素后的容量：10
arrayList1加入第二个元素后的容量：2

        扩容机制在ArrayList中比较重要，相较于普通Array，ArrayList的容量可以动态增加的

        值得注意的是在旧版本Jdk1.6的时候，无参构造的初始容量是10，而后面才改成了空对象赋值。一定程度避免了资源的浪费。