一、ArrayList的底层是数组实现的那么他是如何进行扩容的呢？

我们都知道当创建一个数组时，需要指定其大小，那么ArrayList底层为数组，当我们使用add方法不断添加数据时，他是如何实现自动扩容的呢？

二、创建一个ArrayList集合

代码如下：

List list = new ArrayList();
list.add("fff");

2.查看源码

代码如下：

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

这是ArrayList的构造方法

private static final long serialVersionUID = 8683452581122892189L;

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

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;

这是ArrayList的一些关键属性

3，源码解读

1，构造方法

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

从上面的构造方法中我们可以看见，他给我们初始化啦一个elementData 数组类型为Object，这是一个空数组,那么如果我们此时添加数据是会报错的，他是如何添加数据呢？，

2，add（）

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

可以看见他首先调用ensureCapacityInternal方法并把（size + 1）=1 作为参数
然后elementData自增赋值

3,ensureCapacityInternal(int minCapacity)方法

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

首先调用啦calculateCapacity方法并把其返回值作为参数去调用ensureExplicitCapacity方法

4，calculateCapacity(Object[] elementData, int minCapacity)

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

做一个判断 elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 肯定为true 构造方法接直接赋值的
然后再DEFAULT_CAPACITY, minCapacity之间取最大值DEFAULT_CAPACITY=10的，当第一次调用add时minCapacity=1
所以calculateCapacity 返回值肯定为10

5，ensureExplicitCapacity(int minCapacity)

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

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

modCount自加1，minCapacity – elementData.length > 0 为true minCapacity =10， elementData.length = 0，调用grow方法

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

整个ArrayList扩容机制的关键，oldCapacity =10肯定的
newCapacity = ？”>>” 位运算表示该数的二进制向左移一位
如下图

newCapacity = 15
newCapacity – minCapacity < 0 大于0不成立
newCapacity – MAX_ARRAY_SIZE > 0 不成立

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

MAX_ARRAY_SIZE 是grow上面的一个属性Integer.MAX_VALUE=2147483647
elementData = Arrays.copyOf(elementData, newCapacity);
复制长度为15的一个新数组

也就是说ArrayList是按原来的1.5倍长度进行扩容的