ArrayList扩容机制

1、基本概念

java.util.ArrayList是一个基于动态数组实现的集合框架，它继承了AbstractList抽象类，可以动态的对数组进行大小的创建。

常用的初始化创建一个ArrayList的方法：

1.ArrayList()----------------构造了空的链表。

2.ArrayList(Collection<? extends E> c)------构造了一个包含指定元素集合的链表，字符E是一个标记，用来表示集合中元素的类型。

3.ArrayList(int initialCapacity)---------构造了一个大小确定但内容为空的链表。initialCapacity参数表示初始容量大小。

对于以上三种构造方法的具体源码实现：

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

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     *默认构造函数，使用初始容量10构造一个空列表(无参数构造)
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    /**
     * 带初始容量参数的构造函数。（用户自己指定容量）
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {//初始容量大于0
            //创建initialCapacity大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {//初始容量等于0
            //创建空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else {//初始容量小于0，抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }


   /**
    *构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
    *如果指定的集合为null，throws NullPointerException。 
    */
     public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

当我们使用第一种没有任何参数的构造ArrayList的时候，我们发现ArrayList实际上是一个空的集合，在jdk1.8以前使用的是默认给10个容量，在jdk1.8开始使用的默认为0的Object数组，通过add方法时，再来为其赋值上10的默认容量，这样最大的好处在于制衡空间与时间，是ArrayList的空间效率上得到提高。

2、如何实现扩容

首先我们应先看看ArrayList中著名的add方法。（其中size是ArrayList的私有属性，默认一开始为0）

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

一开始先调用ensureCapacityInternal（size+1），即ensureCapacity（1），ensureCapacity的方法一开始是为了第一次添加数据时为其扩充默认容量或者不是第一次添加数据时，调用ensureExplicitCapacity看能否进行扩容。源码如下：

   //得到最小扩容量
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
              // 获取默认的容量和传入参数的较大值
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

其中由于是第一次添加数据，集合此时还是空，直接进入if语句，通过获取最大值，为minCapacity赋值上10的初始容量。

接着我们进入到ensureExplicitCapacity()方法中，在这个方法中，只要当前最小的容量比数组的长度还长的话，就会进入到grow（）方法中进行扩容。

  //判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //调用grow方法进行扩容，调用此方法代表已经开始扩容了
            grow(minCapacity);
    }

其中grow方法是ArrayList中的扩容核心方法，代码如下：

    /**
     * 要分配的最大数组大小
     */
    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);
    }

这里默认扩充的容量为原始数组的1.5倍，即 newCapacity = oldCapacity + (oldCapacity >> 1);首先这里使用的是采用位运算，位运算比我们平时使用的乘除求余速度会比较快，右移>>即"/2",左移<<即“*2”，实现求余的方法则直接通过“&1”。

在这里官方使用的是扩充1.5倍，那为什么不扩充2陪或者其他倍呢？

在这里我提出我的想法，扩充的倍数太多，则会造成空间的极其浪费，在有限的空间里，1点空间都是极其宝贵的。其实如果扩充得太小，会频繁扩充，造成性能的浪费，1.5倍应该是官方通过数学统计分析的结果，平衡时间与空间，在二者之间找到最合适的位置。

最后通过Arrays.copyOf函数实现数组扩容