ArrayList源码及扩容机制

之前有一次面试

问：你知道ArrayList底层是如何实现的吗？

答：底层是数组…

安静了大概2s后，面试官抬头疑惑的看向了我，我对他笑了笑。那是一段时间很长的沉默，空气中充满了尴尬。我知道希望我继续说下去，但我选择笑着面对这份沉默。

所以！了解底层原理也是很重要的，划重点，期末要考！

ArrayList介绍

ArrayList的底层是数组，相当于动态数组。与Java中的数组相比，它的容量能动态增长。

ArrayList继承于AbstractList，实现了List，RandomAccess, Cloneable, java.io.Serializable 这些接口。

• 继承了AbstractList，实现List。它是一个数组队列,提供了相关的增，删，改，遍历等功能。
• 实现了RandomAccess接口。RandomAccess是一个标志接口，表示实现了这个接口的List集合是支持快速随机访问的。在ArrayList中，我们可以通过元素的序号快速获取元素。
• 实现了Cloneable接口。即覆盖了clone()方法，可以克隆。
• 实现了java.io.Serializable接口。ArrayList支持序列化，能通过序列化传输。

和Vector不同，ArrayList中的操作是非线程安全的。所以建议在单线程中使用ArrayList，在多线程中可以选择Vector或者CopyOnWriteArrayList。

ArrayList源码实现（JDK1.8）

扩容机制，初始化，增删等详细解释直接在源码以注释形式写出。
源码如下：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

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

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

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

    /**
     	保存ArrayList数据的数组
     	元素类型为Object，所以可以为任意类型数据
     */
    transient Object[] elementData; // non-private to simplify nested class access

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

    /**
     * 指定容量的空数组
     */
    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);
        }
    }

    /**
     * 默认构造函数，构造一个空数组。
     * 在第一次添加元素时，容量为10
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * 构造一个指定元素集合的列表
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();	//将集合中的元素放入elementData
        if ((size = elementData.length) != 0) {	//初始化size
            // 如果c.toArray()的数据类型不是Object[],转换为Object[]
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

    /**
     * 修改这个ArrayList的容量为当前大小。
     */
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

	//以下是ArrayList的扩容机制。
	//每次扩容计算出扩容需要的最小容量。

    /**
    	增加当前Arraylist实例的容量，如果必要，确保它至少能容纳元素的数量
    	@param   minCapacity   所需的最小容量
     */
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    
	//得到最小扩容量
    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 static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     * 扩容核心方法
     */
    private void grow(int minCapacity) {
        // 考虑溢出的代码
        int oldCapacity = elementData.length;	//旧长度
        //新长度=旧长度+旧长度/2，也就是说扩容1.5倍。位运算速度远远快于除法运算
        int newCapacity = oldCapacity + (oldCapacity >> 1);	
        if (newCapacity - minCapacity < 0)	//如果新长度比最小值小 则新长度等于最小值
            newCapacity = minCapacity;
            
        //再检查新容量是否超出了ArrayList所定义的最大容量
        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);
    }

	/*
		比较minCapacity和 MAX_ARRAY_SIZE
		如果minCapacity大于MAX_ARRAY_SIZE，则新容量则为Interger.MAX_VALUE，
		否则，新容量大小则为 MAX_ARRAY_SIZE。
	*/
    private static int hugeCapacity(int minCapacity) {
        // 检查minCapacity是否<0,如果是，证明超过最大值（正数溢出变为负数）。
        if (minCapacity < 0) 
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    /**
     * 返回列表元素数量
     */
    public int size() {
        return size;
    }

    /**
     * 判断是否==0，则返回true
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
    	如果此列表包含指定的元素，则返回true 。
     */
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
     * 返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1 
     */
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。.
     */
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    /**
     * 返回此ArrayList实例的浅拷贝。（数组内元素本身不被复制。） 
     */
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            //Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

    /**
      	以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。 
     	返回的数组将是“安全的”，因为该列表不保留对它的引用。
     	因此，调用者可以自由地修改返回的数组。 
     */
    public Object[] toArray() {
    	//elementData：要复制的数组；size：要复制的长度
        return Arrays.copyOf(elementData, size);
    }

    /**
     	以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 
     	返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。 
     	否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。 
     	如果列表适用于指定的数组，其余空间（即数组的列表数量多于此元素），
     	则紧跟在集合结束后的数组中的元素设置为null 。
     */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }
    
    /*
    	将指定的元素追加到此列表的末尾。 
    */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    /**
     	在此列表中的指定位置插入指定的元素。 
     	先调用 rangeCheckForAdd 对index进行界限检查；
     	然后调用 ensureCapacityInternal 方法保证capacity足够大；
     	再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        
        //arraycopy()方法实现数组自己复制自己:让index开始之后的所有成员后移一个位置
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
    
    ...
    
}

modCount

该字段定义在AbstractList中，表示list结构上被修改的次数。

结构上的修改指的是那些改变了list的长度大小或者使得遍历过程中产生不正确的结果的其它方式。

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
 	protected transient int modCount = 0;   
}

该字段被Iterator以及ListIterator的实现类所使用，如果该值被意外更改，Iterator或者ListIterator 将抛出ConcurrentModificationException异常。这是jdk在面对迭代遍历的时候为了避免不确定性而采取的快速失败原则。

       if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }

扩展：System.arraycopy()和Arrays.copyOf()方法

源码中多处使用了这两个方法，看两者源代码可以发现copyOf()内部调用了System.arraycopy()方法。

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

1. arraycopy()需要目标数组，将原数组拷贝到你自己定义的数组里，而且可以选择拷贝的起点和长度以及放入新数组中的位置
2. copyOf()是系统自动在内部新建一个数组，并返回该数组。

ArrayList中的内部类

在ArrayList中，一共有4个内部类

private class Itr implements Iterator<E> {}
private class ListItr extends Itr implements ListIterator<E> {}
private class SubList extends AbstractList<E> implements RandomAccess {}
static final class ArrayListSpliterator<E> implements Spliterator<E> {}

Itr是实现了Iterator接口，同时重写了里面的hasNext()， next()， remove() 等方法；其中的ListItr 继承 Itr，实现了ListIterator接口，同时重写了hasPrevious()， nextIndex()， previousIndex()， previous()， set(E e)， add(E e) 等方法，所以这也可以看出了 Iterator和ListIterator的区别: ListIterator在Iterator的基础上增加了添加对象，修改对象，逆向遍历等方法，这些是Iterator不能实现的。

总结

当需要向ArrayList中添加大量数据时，需要指定容量大小，扩容是一个非常消耗性能的操作，应避免ArrayList频繁扩容。

ArrayList底层是数组，通过索引直接得到元素，如add(E)和get(int)，时间复杂度为O(1)。

当对指定位置进行插入或删除时，需要将对应索引位置后的所有元素进行移动，时间复杂读为O(n)。

ArrayList性能的好坏取决于操作位置距离数组末端的距离。