ArrayList源码分析

ArrayList

ArrayList是基于动态数组实现的，支持随机访问，它继承自AbstractiList，RandomAccess标识着它支持随机访问

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList的默认大小为10

private static final int DEFAULT_CAPACITY = 10;

它有如下三种构造方式：

ArrayList arr = new ArrayList();//默认大小为10
ArrayList arr1 = new ArrayList(5);//创建一个容量为5的ArrayList
ArrayList arr2 = new ArrayList(Collection<? extends E> c);//构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。

但是我们看接下来的源码

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
   };

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

当我们使用无参的构造函数去构造一个ArrayList的时候，他会给elementData一个值，也就是说这个时候这个elementData数组还是没有容量的，并不是说创建之初容量就为默认容量10，那么它是在什么时候将容量扩容为10的呢，答案是加进第一个元素的时候

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

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

可以看到在ensureCapacityInternal中，有判断此时elementData数组的一个状态，如果值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA就会将容量设为默认容量

扩容

在ArrayList增加元素的时候，会使用ensureCapacityInternal()来确保容量足够，用grow()来扩容数组，扩容为原来的1.5倍

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

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

private void ensureExplicitCapacity(int minCapacity) {
   
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(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);
}

我们来捋一捋这个顺序
1、增加元素的时候，先用ensureCapacityInternal()确保容量足够，首先这个方法会判断你创建的是否是默认容量的ArrayList，然后调用ensureExplicitCapacity()，将所需容量大小传进去当参数
2、ensureExplicitCapacity()方法将modCount加1，这是个快速失败检查的标志，后面会讲到，同时在这个方法里面判断是否超过了容量大小，超了就执行grow()方法
3、我们看到grow()方法有两个判断，我们来分析一下
首先,这里将数组容量扩容到原本的1.5倍，oldCapacity>>1相当于oldCapacity/2；

int newCapacity = oldCapacity + (oldCapacity >> 1);

这是第一个判断，意思是如果扩容后的新容量仍然达不到要求的话，就将所需容量作为新容量

if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

这是第二个判断，意思是如果扩容后的新容量超过了ArrayList的最大容量，就会调用hugeCapacity()方法，并传入所需容量作为参数，MAX_ARRAY_SIZE值为Integer.MAX_VALUE- 8，至于为什么是比整数的最大值小8，这就交给大神们去解答吧

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

最后，注意这里用了copyOf()来创建新的数组，所以每一次扩容对系统的耗费都很大，我们应该尽量在最开始的时候就给定大概的容量，减少扩容的次数

 elementData = Arrays.copyOf(elementData, newCapacity);

删除元素

ArrayList删除元素的整体思路是用System.arraycopy()方法将index+1位置上的元素以及之后的元素前移，可以看出ArrayList删除元素的耗费是非常大的

public E remove(int index) {
   
    rangeCheck(index);
    modCount++;
    E oldValue = 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;
}

Fail-Fast

Fail-Fast即快速失败机制，主要通过属性modCount来判断ArrayList的结构是否被修改，添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，都会改变ArrayList的结构，但是仅仅只是设置元素的值不算结构发生变化。

Fail-Fast机制是在进行序列化或者迭代等操作时，比较前后的modCount是否一样,如果改变了需要抛出 ConcurrentModificationException。

为什么要Fail-Fast机制呢，因为ArrayList不是线程安全的，如果有两个线程同时对一个ArrayList做修改的时候，每一方都是不知情的，这个时候就需要Fail-Fast机制来提醒线程此ArrayList被其他线程做了修改

我们可以看个例子，下面是序列化时需要使用的 ObjectOutputStream 的 writeObject() 方法

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
   
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
   
        s.