【Java集合】试读ArrayList源码

ArrayList简介

ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。稍后，我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。

ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。

ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。

（前面都是复制粘贴的图和文字，大家大概理解一下，下面进入正题）

首先我们要明白一点，ArrayList的本质就是数组。

所以我们的源码，首先从ArrayList中维护的两个数组变量开始，它们是ArrayList的核心：

//该数组缓存者集合中的元素，集合的容量就是该数组的长度，elementData用transient修饰，说明在序列化时，数组elementData不在序列化范围内。
private transient Object[] elementData;

//集合的大小 （集合中元素的实际数量）
private int size;

接下来看一下ArrayList的构造器：

//ArrayList带容量大小的构造函数，容量大于0，则生成对应容量的数组，容量等于0，则把空数组EMPTY_ELEMENTDATA赋给它，容量小于0则报错
    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无参构造函数，则把空数组DEFAULTCAPACIT_EMPTY_ELEMENTDATA赋给它，但是这个空数组拥有一个默认的数组容量
    public ArrayList() {
        this.elementData = DEFAULTCAPACIT_EMPTY_ELEMENTDATA;
    }

    // 创建一个包含传入collection的ArrayList，若这个Collection为空，则把空数组EMPTY_ELEMENTDATA赋给它；若不为空，通过Collection的toArray（）方法生成一个数组
    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.7
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

这时候问题出现了，里面的EMPTY_ELEMENTDATA和DEFAULTCAPACITY_EMPTY_ELEMENTDATA是什么鬼？都是空数组有什么区别呢？

//默认数组容量10
private static final int DEFAULT_CAPACITY = 10;

//空的数组，数组大小为0
private static final Object[] EMPTY_ELEMENTDATA = {};

//空的数组，但是数组大小为默认数组大小10
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

这个所谓的数组容量有什么用呢？

我们接着看下常用的get（） 、set（）和add（）这几个方法：

//封装的获取index位置的元素值方法，避免强转
    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    // 获取index位置的元素值
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

    // 设置index位置的值为element
    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

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

     // 将e添加到ArrayList的指定位置
    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++;
    }

get（）方法和set()方法比较简单，都是判断一下是否越界，然后根据数组索引来找值。判断越界（包含add方法的越界判断）的代码如下：

   //判断是否index是否过界
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    //判断是否index是否过界，用于add和addAll方法
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

add（）方法中有一个System.arraycopy（），主要用于数组内的数的复制。由于源代码不是Java写的，我这边只稍微写一下用法：

System提供了一个静态方法arraycopy(),我们可以使用它来实现数组之间的复制。其函数原型是：

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

src:源数组；
srcPos:源数组要复制的起始位置；
dest:目的数组；
destPos:目的数组放置的起始位置；
length:复制的长度。
注意：src and dest都必须是同类型或者可以进行转换类型的数组．
有趣的是这个函数可以实现自己到自己复制，比如：
int[] fun ={0,1,2,3,4,5,6};
System.arraycopy(fun,0,fun,3,3);
则结果为：{0,1,2,0,1,2,6};

而之前构造器中的Arrays.copyOf（）方法，也有调用这个system.arraycopy方法，从而实现数组的扩容（当然还有Arrays.copyOf（）方法还有其他功能，此处姑且不谈）：

System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));

我们同时发现发现add方法中有一个ensureCapacityInternal（）方法，这个就涉及到了我们刚刚说到的容量，我们接下来看一下源码： // 确定ArrarList的容量。

 //确定ArrarList的容量。
    private void ensureCapacityInternal(int minCapacity) {
        //若数组为无参构造形成的数组，则minCapacity为传入值和默认值中的最大值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        //若传入值比当前的数组长度大，则要增加数组长度
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    //不出现OutOfMemory的最大数组容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    //增加数组容量
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //新的容量为原来的1.5倍
        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;
    }

ensureCapacityInternal（）方法就是确认ArrayList的容量是否满足要求。

若当前数组是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则取传入的容量和默认容量中的较大值，来进行后面的增加容量操作。
也就时说，默认容量较大时，把默认容量认为是当前数组的容量。

同样，有另外一个对外的公共方法ensureCapacity（），也是确认ArrayList容量的功能，在是否为默认空间的时候都进行了一次判断，然后才调用ensureCapacity（）方法：

  public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            //数组不是默认的容量
            ? 0
            //数组容量比默认的大
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

最后增加数据的部分看一下和addAll方法的源码：

  // 将集合c追加到ArrayList中，把容量新增一个collection的长度，然后在后面新增collection中的元素
    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;
    }

    // 把容量新增一个collection的长度，从index位置开始，将集合c添加到ArrayList
    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;
    }

我们再看删除的方法：

 // 删除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;
    }

    // 删除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;
    }

    // 快速删除第index个元素
    private void fastRemove(int index) {
        modCount++;
        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
    }

    // 清空ArrayList，将全部的元素设为null
    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

可以看到，每在中间删除或者增加一个元素，旁边的元素都要跟着移动一遍， 非常麻烦。

然后看元素的搜索：

// 获取index位置的元素值
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

  // 返回ArrayList是否包含Object(o)
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    // 正向查找，返回元素的索引值
    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;
    }

    // 反向查找，返回元素的索引值
    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 int size() {
        return size;
    }

    // 返回ArrayList是否为空
    public boolean isEmpty() {
        return size == 0;
    }

         // 将当前容量值设为实际元素个数
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

       // 克隆函数
    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);
        }
    }

最后稍微看一下里面的迭代器方法，代码如下：

        private class Itr implements Iterator<E> {
            int cursor;       // index of next element to return
            int lastRet = -1; // index of last element returned; -1 if no such
            int expectedModCount = modCount;

            public boolean hasNext() {
                return cursor != size;
            }

            @SuppressWarnings("unchecked")
            public E next() {
                checkForComodification();
                int i = cursor;
                if (i >= size)
                    throw new NoSuchElementException();
                Object[] elementData = ArrayList.this.elementData;
                if (i >= elementData.length)
                    throw new ConcurrentModificationException();
                cursor = i + 1;
                return (E) elementData[lastRet = i];
            }

            public void remove() {
                if (lastRet < 0)
                    throw new IllegalStateException();
                checkForComodification();

                try {
                    ArrayList.this.remove(lastRet);
                    cursor = lastRet;
                    lastRet = -1;
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }

            @Override
            @SuppressWarnings("unchecked")
            public void forEachRemaining(Consumer<? super E> consumer) {
                Objects.requireNonNull(consumer);
                final int size = ArrayList.this.size;
                int i = cursor;
                if (i >= size) {
                    return;
                }
                final Object[] elementData = ArrayList.this.elementData;
                if (i >= elementData.length) {
                    throw new ConcurrentModificationException();
                }
                while (i != size && modCount == expectedModCount) {
                    consumer.accept((E) elementData[i++]);
                }
                // update once at end of iteration to reduce heap write traffic
                cursor = i;
                lastRet = i - 1;
                checkForComodification();
            }

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

里面的具体方法不具体展开讲，我们重点关注一下checkForComodification()方法。

眼尖的朋友可能已经发现了，在前面的add(),addAll(),clear等改变数组值的方法中，都有一个操作

modCount++;

这个modCount是什么？这个操作又代表着什么呢？

事实上，这个数是定义在ArrayList的父类AbstractList中的：

protected transient int modCount = 0;

这个数的用处我们结合checkForComodification()方法来看，：

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

这个方法就是判断，当modCount不等于expectedModCount，则抛出异常。

从Itr类中，我们知道 expectedModCount 在创建Itr对象时，被赋值为 modCount。通过Itr，我们知道：expectedModCount不可能被修改为不等于 modCount。所以，当且仅当modCount被修改时，会抛出异常。

这种异常的出现，源自于java集合(Collection)中的一种错误机制：

fail-fast 机制

当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。
例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。

　　

具体到代码中：

当多个线程对同一个集合进行操作的时候，某线程访问集合的过程中，该集合的内容被其他线程所改变(即其它线程通过add、remove、clear等方法，改变了modCount的值）；这时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。

所以这个modCount就是用来判断集合的内容是否在iterator遍历过程中被改变的一个参数。

总结一下：

1.ArrayList是用数组实现的，所以查找元素时直接通过Index查找，比较快；可是新增或者删除元素就慢了，要大量的移动数组里的数。
2.ArrayList新增数据的时候，可能会引起容量的扩充，但是删除数据却不会造成容量的减小，只能用trimToSize()方法来把数组容量减小为实际元素个数。
3.扩充容量的方法ensureExplicitCapacity。新增操作或者是客户端主动调用ensureCapacity（）方法时，如果容量不足了，就设置新的容量为旧的容量的1.5倍，如果设置后的新容量还不够，则直接新容量设置为传入的参数，而后用Arrays.copyof()方法将元素拷贝到新的数组。容量经常变化，导致元素多次拷贝的话，非常耗时

4.modCount就是用来判断集合的内容是否在iterator遍历过程中被改变,若被改变了会产生fail-fast事件。