重温ArrayList

构造方法

ArrayList，官方提供了三个构造方法：

第一个构造方法：

 public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

 我们看到，ArrayList的第一个构造方法为无参构造，直接给变量elementData赋值了一个空数组：

transient Object[] elementData; // non-private to sim

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

第二个构造方法：

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

 第二个构造方法，传入的参数，是int类型的参数，是用来设置数组的大小。

如果容量大于0，则new一个大小为initialCapacity、Object类型的数组，并赋值给elementData；

如果容量为0，则赋值一个空数组给elementData：

private static final Object[] EMPTY_ELEMENTDATA = {};

第三个构造方法：

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

第三个构造方法的传参为Collection类型，首先把，传进来的的Collection类型的变量转为数组赋值给elementData。

然后判断数组的长度如果不等于0，判断一下elementData的类型，如果是Object[].class，那么需要通过数组拷贝转换为Object[].class类型的数组。

如果数组长度等于0，那么赋值一个空数组给elementData。

add方法

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

add 方法中只有三行代码，我们首先看下ensureCapacityInternal方法：

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

        ensureExplicitCapacity(minCapacity);
}

首先add方法是往集合中添加元素，而且是每调用一次添加一个元素。所以没添加一个元素，相当于集合的大小变为了当前集合的大小size，做加1操作。所以是size+1，便是添加元素后，集合的大小。所以要想添加这一个元素，至少所需要数组的最小长度minCapacity为size+1。

而ensureCapacityInternal方法就是为了保证添加新元素时，数组有足够的长度去添加。具体看：

（1）首先判断elementData数组的大小是否是空数组，如果是空数组，那么DEFAULT_CAPACITY和minCapacity的最大值，给minCapacity重新赋值。

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

DEFAULT_CAPACITY的值是10。所以这里意思是说，如果ArrayList对应的是空数组，添加元素的话，会给ArrayList对应的数组设置大小为10的长度。（也就是说add方法之后，数组的长度至少是10。（注意：这里的size是指ArrayList集合的大小。而DEFAULT_CAPACITY，这些是指的ArrayList对应的数组的长度。这里不是一回事））

举例：

add一个元素“HELLO”：

{null,null,null,null,null,null,null,null,null,null}

添加一个元素后：

{"HELLO",null,null,null,null,null,null,null,null,null}

。所以elementData数组的长度为10，而ArrayList的大小size为1。二者不一样

（2）ensureExplicitCapacity方法：

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

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

这里的modCount，是记录操作的。比如元素的添加或删除modCout都会++，这和我们主要讲的暂无关联，这里不做过多解读。

这里判断，如果添加元素所需的最小空间大于当前数组的长度的话，就需要通过grow方法给数组扩容了。

（3）grow方法：

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

oldCapacity：数组的长度。

newCapacity：扩容后数组的长度，oldCapacity + (oldCapacity >> 1)。相当于1.5倍的oldCapacity。（所以通过这里，我们可知，ArrayList扩容是扩容为了原数组长度的1.5倍）。

如果扩容1.5倍后，数组的长度还是没有达到添加元素所需的最小长度。那么就将扩容后数组的长度定为所需的最小长度。

如果扩容后的长度大于MAX_ARRAY_SIZE，那么就将扩容长度定义为hugeCapacity(minCapacity)方法返回的长度。

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

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

接下来就是通过 Arrays.copyOf(elementData, newCapacity) 方法复制数组，有两个参数：一个是elementData（要复制的数组），一个是newCapacity（扩容后数组的长度）。

扩容后将copy得到的新数组赋值给elementData，这样就实现了。数组的扩容操作。

到这里数组的扩容就解读完了。然后我们回到add方法中，看下第二行代码：

elementData[size++] = e;

这行代码很简单，相信不用多说，大家都能明白。数组扩容后，数组中对应的索引处，指向新的元素，同时注意这里，size做了++操作，相当于集合的size大小+1了 。

到这里就完成了ArrayList的add操作。

void 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++;
}

此方法是ArrayList插入元素到数组中的某一索引处。

从传参我们可以看出，

第一个参数index是，要插入到数组中的指定的索引；

第二个参数element，是要插入到数组中的元素。

首先判断如果index比当前集合的大小大，或者index<0,那么直接抛出数组越界的异常。

ensureCapacityInternal方法我们不用过多解读，上面已经说过了，主要是为了保证插入元素时，数组有足够的长度。

然后主要还是通过数组拷贝，实现数组长度+1：

System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);

上面的代码实现了，把数组elementData中，从索引为index的元素，复制到了索引从index+1开始，复制的长度是：size-index。

紧接着给索引出index的元素赋值element：

elementData[index] = element;

 最后：

 size++;

集合长度加1。

大概流程是这样：

比如插入一个元素“BIG”到index=2处的流程：

插入前的数组：

{“A” , "B" , "C" , "D" , "E" , null , null , null , null , null}

首先通过扩容方法 ensureCapacityInternal 后数组还是这样（因为size=5，size+1=6，所以

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

不会执行grow方法进行扩容）：

{“A” , "B" , "C" , "D" , "E" , null , null , null , null , null , null }

经过System.arraycopy后变为这样：

{“A” , "B" , "C" , "C" , "D" , "E" , null , null , null , null }

然后经过 elementData[index] = element; 后：

{“A” , "B" , "BIG" , "C" , "D" , "E" , null , null , null , null }

然后size++；集合的大小由5变为了6。

到这里  void add(int index, E element)方法 就执行完了。

 E remove(int index)

 public E remove(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        modCount++;
        E oldValue = (E) elementData[index];

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
}

（1）首先判断index的值，如果大于等于集合的大小，那么就直接抛出数组越界。

（2）通过索引拿到对应的元素，赋值给oldValue

（3）通过size-index-1 来计算复制过程中需要移动的元素的个数：

然后通过System.arraycopy方法进行复制

移除的流程大概这样：

比如移除index=2处的元素的流程：

移除前的数组：

{“A” , "B" , "BIG" , "C" , "D" , "E" , "" , "" , "" , ""}

System.arraycopy复制后：

{“A” , "B" ,"C" , "D" , "E" , "E" , null , null , null , null }

（4）继续执行：elementData[--size] = null; 后：

{“A” , "B" ,"C" , "D" , "E" , null , null , null , null , null }

到这里就实现了ArrayList通过index的remove元素的操作。