java源码品读（7）— ArrayList（一）

ArrayList是list的一个重要的实现，是经常会在代码中见到的一个几个，值得我们仔细的看一看。

ArrayList继承AbstractList类，实现List、RandomAccess,、Cloneable、java.io.Serializable等接口，AbstractList、List、RandomAccess在之前的博文中都有说道，Cloneable、Serializable接口跟RandomAccess类似，接口没有需要实现的方法，是一种功能标志接口，Cloneable标志支持clone操作，Serializable标志支持序列化功能。

ArrayList是大小可变的数组实现，实现了list中的所有可选的操作，允许所有的元素当然也包括null元素，除去list接口中定义的各种操作，ArrayList内部还提供了巧妙改变数组大小的方法，ArrayList大致上跟Vector类似，或者说是非同步的Vector。

ArrayList各种操作中，size、isEmpty、get、set、iterator、listIterator操作的时间复杂度较低，因为ArrayList支持随机访问，所以这类操作的时间复杂度为O(1)；add方法的时间复杂度较高为O(n)；其他方法的时间复杂度都是线性的。

ArrayList并不是现行安全的，也因此iterators是fail-fast的：iterator产生之后如果list发生变化（add、remove操作），list就会在最快的时间内抛出ConcurrentModificationException（不懂fail-fast可以点这里简单了解下），所以呢若在多线程环境下并发访问一个ArrayList实例，并且至少一个线程对其作了结构型修改，那么必须在外部做同步。

下面来细细地看一看ArrayList内部的一些东西：

变量

//序列化需要的序列码
private static final long serialVersionUID = 8683452581122892189L;
//默认的大小，使用默认构造器初始化大小为10的数组
private static final int DEFAULT_CAPACITY = 10;
//默认空数组，初始化大小为0时使用
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认空数组，初始化大小为默认10时使用，当添加第一个元素的时候，这个数组的大小便会被初始化为默认大小，
//便能与EMPTY_ELEMENTDATA区分开
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//存放元素的数组，transient修饰表示表示这个变量不属于序列化的一部分
transient Object[] elementData; 
//ArrayList的大小，与elementData的大小一致
private int size;
//最大的数组大小，
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

大部分都好理解，就是这个elementData在初看的时候会有一点疑惑，ArrayList是支持序列化的，但是存放元素的数组又不支持序列化，岂不是ArrayList经历序列化和反序列之后元素全部都挂掉了？不知道各位在刚看的时候会不会像笔者一样有这个疑惑，这个先放着，我们把相关的方法解释完自然会明白。
其他的，为什么最大的数组大小比正数最大值少8之前有说过，可以翻看之前的博文AbstractCollection

构造器

//无参构造器，存放元素的数组为DEFAULTCAPACITY_EMPTY_ELEMENTDATA
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//接收一个大于等于0的int型值作为数组初始大小，如果初始值为0，存放元素的数组为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);
    }
}
//接收一个集合类型的参数，将集合中的元素复制进ArrayList存放元素的数组中
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;
    }
}

方法

• trimToSize()方法

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
    }
}

将集合的容量为集合当前的大小，最小化集合的操作

• ensureCapacity(int minCapacity)方法

    public void ensureCapacity(int minCapacity) {
        //获取当前元素存放数组大小
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0 : DEFAULT_CAPACITY;
        //当前数组大小小于期望大小时进行扩容
        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    private void ensureExplicitCapacity(int minCapacity) {
        //增加改变次数
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        //新集合的默认扩容大小是集合大小的1.5倍
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果默认扩容大小小于期望容量，新集合扩容大小为期望容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    //如果默认扩容大小大于大于正数最大值，会根据期望容量的大小设定新的集合大小
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

从整个集合扩容的过程中能得到的信息：
1、默认构造器创建的arrayList初始的容量为0，从添加第一个元素开始初始容量扩展为10
2、arrayList的最大容量为int型的最大值

既然看了扩容的方法，那么我们就把跟扩容相关的方法整个看完：

• add(E e)、add(int index, E element)
• addAll(Collection <? extends E> c)、addAll(int index, Collection<? extends E> c)

public boolean add(E e) {
    //扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //默认添加在集合的最末尾
    elementData[size++] = e;
    return true;
}
public void add(int index, E element) {
    //检验index值是否合理
    rangeCheckForAdd(index);
    //扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //复制并后移
    System.arraycopy(elementData, index, elementData, index + 1,size - index);
    elementData[index] = element;
    size++;
}
//两个addall方法的套路跟add(int index, E element)的方式差不多，只是复制赋值的时候参数稍微有些区别
//这里笔者有一个疑惑，如果参数集合元素个数为0，addall方法其实没有让集合发生任何改变，为什么不直接返回？
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;
}
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;
}
//确定期望扩容的大小，然后调上面说的扩容方法实现扩容
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) 
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    return minCapacity;
}

• contains(Object o)、indexOf(Object o)、lastIndexOf(Object o)

//用获取的下标大小来实现
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;
}
//作用与indexOf相同，只不过顺序相反
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;
}

• clone()方法

public Object clone() {
     try {
     //返回跟之前一样的ArrayList，其他一样，但刷新修改次数
         ArrayList<?> v = (ArrayList<?>) super.clone();
         v.elementData = Arrays.copyOf(elementData, size);
         v.modCount = 0;
         return v;
     } catch (CloneNotSupportedException e) {
         //未实现cloneable接口会抛出此异常
         throw new InternalError(e);
     }
 }

• toArray()方法

//相比于AbstractCollection的实现更加简洁，在于ArrayList中有用于存放元素的数组
public Object[] toArray() {
   return Arrays.copyOf(elementData, size);
}
public <T> T[] toArray(T[] a) {
    //指定集合的容量小的话会新产生一个集合再进行复制，否则直接赋值且复制完原ArrayList中的元素之后，
    //赋值一个null，其他的元素还跟指定集合的元素一样，这个有一些诡异，不知出于何种目的（仅仅是分隔线么）？
    if (a.length < size)
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

• get(int index)、set(int index, E element)
  比较常用的两个方法，都会先进行参数的检查然后进行后续的操作。

public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}
public E set(int index, E element) {
   rangeCheck(index);
   E oldValue = elementData(index);
   elementData[index] = element;
   return oldValue;
}

• remove(int index)、remove(Object o)方法

//先改变modcount值
//然后根据index删除元素：实质上是index的位置的元素被后续元素覆盖，最后一个元素赋值为null
//感觉也可以调用fastRemove方法
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;
    return oldValue;
}
//直接删除元素会有一个查找的过程，后续跟remove(int index)方法一致
//如果ArrayList中有相同元素，只删除位置靠前的那一个
public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
private void fastRemove(int index) {
   modCount++;
   //从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
}
//跟上面的方法基本是一个套路，只是参数的整理多一点
protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;
    System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved);
    int newSize = size - (toIndex-fromIndex);
    for (int i = newSize; i < size; i++) 
        elementData[i] = null;
    size = newSize;
}

• clear()方法

public void clear() {
    modCount++;
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    size = 0;
}

清空集合的方法：先改变modcount值，而后循环把每一个元素变为null

• removeAll(Collection<?> c)、retainAll(Collection<?> c)

//删除出现在指定集合中的所有元素
public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}
//只保留出现在指定集合中的元素
public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, true);
}
private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    //逐个进行筛选，r表示进行到的位置，w表示符合要求的个数
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        //容灾性代码，即使contains方法抛出异常，完成多少就保存多少
        if (r != size) {
            System.arraycopy(elementData, r, elementData, w, size - r);
            w += size - r;
        }
        //成功删除多少个，就赋值几个null
        if (w != size) {
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

• readObject(java.io.ObjectInputStream s)、writeObject(java.io.ObjectOutputStream s)方法
  这两个方法就是文章开始时候说的那个疑问：elementData用transient关键字修饰的原因
  ArrayList内部使用数组来实现元素的存储，而在序列化的时候我们并不希望去序列化那些无用的元素，仅仅只序列化和反序列化我们需要的size()个元素，所以才使用transient关键字，让数组本身不能被序列化，而使用指定的方法对数组持有的对象进行序列化。

private void readObject(java.io.ObjectInputStream s) 
            throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;
    //读入size和其他隐藏的东西
    s.defaultReadObject();
    //读入容量
    s.readInt(); 
    if (size > 0) {
        int capacity = calculateCapacity(elementData, size);
        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
        ensureCapacityInternal(size);
        Object[] a = elementData;
        for (int i=0; i<size; i++) {
            //读取数组中的每一个元素
            a[i] = s.readObject();
        }
    }
}
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
    int expectedModCount = modCount;
    //写入元素个数和其他隐藏的东西
    s.defaultWriteObject();
    //写入容量值
    s.writeInt(size);
    for (int i=0; i<size; i++) {
        //写入每一个数组元素
        s.writeObject(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

这就是ArrayList前800行的源码，之后还有700行的代码主要是迭代器、子集合、可分割集合的相关实现和其他一些小的方法，写在一起貌似有点太多了，就分开写好了。