【Java容器】ArrayList源码阅读笔记

ArrayList是一个非常重要Java容器，下面是ArrayList的源码阅读笔记。

ArrayList的父类和实现的接口

首先我们先看ArrayList继承的类和实现的接口

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

我们可以看到ArrayList继承父类AbstractList，并且实现了List, RandomAccess, Cloneable和Serializable接口。

我们首先看实现的RandomAccess, Cloneable和Serializable三个接口

public interface Serializable{
}

public interface RandomAccess{
}

public interface Cloneable{
}

从源码中看到三个接口什么都没有，那么它们到底是用来做什么的呢？

查阅JDK1.8API，可以知道
Serializable接口：

类的序列化由实现java.io.Serializable接口的类启用。 不实现此接口的类将不会使任何状态序列化或反序列化。
可序列化类的所有子类型都是可序列化的。 序列化接口没有方法或字段，仅用于标识可串行化的语义。

意思大致是实现了Serializable接口的类才能进行序列化和反序列化，Serializable接口里没有方法或字段，只是用来标识一个类可以进行串行化。

RandomAccess接口：
JDK1.8API中描述：

public interface RandomAccess
Marker interface used by List implementations to indicate that they support fast (generally constant time) random access.

上面这句话大致是说RandomAccess接口也是起一个标志的作用，表明实现了该接口的List集合是支持快速随机访问的。

同时，官方文档也说了实现了该接口的List，使用for循环读取数据会比使用迭代器更快。

As a rule of thumb, aList implementation should implement this interface if, for typical instances of the class, this loop:
​ for (int i=0, n=list.size(); i < n; i++)
list.get(i);
​ for (Iterator i=list.iterator(); i.hasNext(); )
i.next();

Cloneable接口：

官方文档中说，一个类实现Cloneable接口，是用于指示Object.clone()方法，使得Object.clone()对该类的实例进行现场复制是合法的。并且，在没有实现Cloneable接口的实例上调用克隆方法会抛出CloneNotSupportedException 异常。通常，实现Cloneable接口必须使用公共方法覆盖Object.clone()方法（受保护）。

说完三个接口，下面我们说说List接口和继承的父类AbstractList

List接口:

List 接口继承了 Collection
接口以定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理，还添加了面向位置的操作。

List 接口不但以位置序列迭代的遍历整个列表，还能处理集合的子集：

List接口实现的方法：

List接口中的方法主要是对有序集合进行各种操作。

对于AbstractList，百度解释为：

此类提供 List 接口的骨干实现，从而最大限度地减少了实现由“随机访问”数据存储（如数组）支持的接口所需的工作。对于连续的访问数据（如链表），应优先使用AbstractSequentialList，而非此类。

查看源码也可观察到，AbstractList对List中的大部分方法进行了实现，以及上方提到的Object.clone方法也进行了重写（实现了Cloneable接口）。

public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            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);
        }
    }

同时也发现，AbstractList虽然是一个抽象类，但它却只有一个抽象方法

abstract public E get(int index);

从字面上看这是获取的方法，子类必须实现它，一般是作为获取元素的用途，除此之外，如果子类要操作元素，还需要重写 add(), set(), remove() 方法，因为 AbstractList 虽然定义了这几个方法，但默认是不支持的。

public boolean add(E e) {
    add(size(), e);
    return true;
}
public void add(int index, E element) {
    throw new UnsupportedOperationException();
}
public E set(int index, E element) {
	throw new UnsupportedOperationException();
}
public E remove(int index) {
	throw new UnsupportedOperationException();
}

可以看到，在其默认实现里，直接是抛出UnsupportedOperationException 异常的。

LETS LOOKLOOK ArrayList源码

介绍完ArrayList的父类和实现接口，下面我们正式进入ArrayList源码：

我们先看ArrayList主要的成员变量：

	//用于java序列化机制，验证版本一致性
	private static final long serialVersionUID = 8683452581122892189L;

    //数组默认大小
    private static final int DEFAULT_CAPACITY = 10;
	
    //动态数组，存数据
    transient Object[] elementData; // non-private to simplify nested class access
    
    //空数组时
	private static final Object[] EMPTY_ELEMENTDATA = {};

    //ArrayList大小
    private int size;

成员变量包括serialVersionUID，数组默认大小DEFAULT_CAPACITY，动态数组elementData，以及数组大小size。

这里需要注意的是：动态数组被transient修饰，在序列化时会被忽略。ArrayList定义了writeObject()和readObject()方法（都是私有方法）来实现序列化。

ArrayList的构造方法：

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

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

public ArrayList(Collection<? extends E> c) {
     elementData = c.toArray();
     if ((size = elementData.length) != 0) {
         
         if (elementData.getClass() != Object[].class)
             elementData = Arrays.copyOf(elementData, size, Object[].class);
     } else {
         this.elementData = EMPTY_ELEMENTDATA;
     }
 }

ArrayList有三种构造方法：(1).无参构造 (2).传入初始数组大小进行构造 (3)使用collection对象进行构造。（注意当数组大小为空的时候是直接将EMPTY_ELEMENTDATA赋给elementData的）

增加元素：

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

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, 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.5倍，将扩大后的容量和需要容量的比较，取更大的那个值，然后调用Arrays.copyOf()方法得到新的数组，最后将元素插入。增加单个元素和增加一个Collection的情况基本类似，在这里就不细说了。

插入元素：

public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                         numMoved);

    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

插入操作的具体流程也比较简单，大致过程：先检查数组大小，判断是否需要扩容；然后调用arraycopy(Object src, int srcPos,Object dest, int destPos,int length)方法将从插入位置（index）开始到数组尾的数据全部向后移动一位，再在index位置插入值。

删除元素操作：

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

删除一个元素就是调用System.arraycopy方法将它后面的元素向前拷贝，将需要删除的元素覆盖即可。

从上面可以看出ArrayList删除和插入的效率比较低。

总结

简单介绍了ArrayList的父类和实现的接口，从源码上分析了ArrayList的构造方法，增加、插入和删除元素的方法。

参考资料

JDK1.8 API