ArrayList源码解析--值得深读

ArrayList源码解析

基于jdk1.8

ArrayList的定义

类注释

• 允许put null值，会自动扩容；
• size isEmpty、get、set、add等方法时间复杂度是O(1)；
• 是非线程安全的，多线程情况下推荐使用CopyOnWriteArrayList或者Vector。
• 增强for循环或使用迭代器过程中，如果数组大小被改变会抛出异常。

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

从源码中我们可以看出，ArrayList继承了AbstractList，实现了List接口，RandomAccess，Cloneable，Serializable接口。

实现List接口提供了元素的添加、删除。修改。遍历等功能。
实现RandomAccess接口，他是一个标志性接口，表明实现这个接口后，List集合支持随机访问。
实现Cloneable接口表明ArrayList可以被克隆
实现Serializable接口表示ArrayList支持序列化，能被传输。

ArrayList是一个动态数组，与普通数组相比他的容量可以动态的扩容。

ArrayList的有关属性

 private static final long serialVersionUID = 8683452581122892189L;

    /*默认容量大小是10*/
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 用来共享空数组实例
     * 我们把它和EMPTY_ELEMENTDATA数组区分出来，当添加第一个元素的时候知道需要扩增多少容量
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 保存ArrayList数据的数组
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * 集合包含元素的个数
     */
    private int size;

ArrayList的构造函数

public ArrayList(int initialCapacity) {
        // 如果创建的时候传入的有值，并且大于0，就直接创建大小是传入的值的数组
        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;
    }

    /**

     *构造函数的参数是一个集合，如果集合为null，会抛空指针异常
     *
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        //如果集合的大小不为0 就通过Arrays.copy方法，把Object数组的元素一一复制到elementData数组中
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            // 注意这是java的一个bug，c.toArray()方法返回值可能不是Object数组，这里转成Object类型
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
        //如果集合里没有元素就是一个空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

上面的那个// c.toArray might (incorrectly) not return Object[] (see 6260652)一般情况下都不会触发这个bug ,这里演示一下是怎么出现的。

public void testConstructor() {
        List<String> arrayList = Arrays.asList("Hello");
        //toArray方法返回Object数组类型
        Object[] objects = arrayList.toArray();
        log.info(objects.getClass().getSimpleName());
        // 打印出来是 String[]

        //这样写是对的
        //objects[0]="Java";

        //这样就会报错因为数组元素的类型是String
        objects[0] = new Object();
    }

不过这个bug已经在Java9解决。

新增和扩容的实现

新增元素

/**
     * Appends the specified element to the end of this list.
     *增加元素到集合的末尾
     *
     */
    public boolean add(E e) {
           //先扩容，使容量+1
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    /**
     * 在指定位置增加元素
     *
     * @param index index at which the specified element is to be inserted
     * @param element element to be inserted
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public void add(int index, E element) {
       //检查增加的位置是否越界
       rangeCheckForAdd(index);
        //扩容，size+1
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //元素的复制，将 index之后的元素往后 移动一位，size++；
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
                         //最后在index位置上赋值
        elementData[index] = element;
        size++;
    }

扩容

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

    private void ensureExplicitCapacity(int minCapacity) {
       //记录数组被修改的次数加1
       modCount++;

        // 如果我们期望的数组大小大于目前的数组长度，那么就扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    //扩容方法
     private void grow(int minCapacity) {
        // 先记录旧的数组大小
        int oldCapacity = elementData.length;
        //扩容后的容量=扩容前的+扩容前的大小/2,也就是说扩容后的值是原来的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果扩容后的值，小于期望的大小，那扩容后的值就改为期望值
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;

        //如果扩容后的值大于jvm所能分配的最大值，那么就用Integer.MAX_VALUE.，否则等于MAX_ARRAY_SIZE
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 最后数组复制，底层是System.arraycopy()方法
        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.5倍。
• ArrayList中的数组长度最大是Integer.MAX_VALUE,超过这个值，JVM就不会给数组分配内存空间了。
• 新增时，并没有对新增元素进行严格校验，所以可以新增null。

其实我们可以看出，大多数方法中都用到了Arrays.copyOf方法

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

再看System.arraycopy

//src 是原数组，srcPos是原数组的位置，dest是目标数组，destPOS是目标数组的位置，length是拷贝的长度，这个方法是native方法，所以底层可能是C/C++编写的
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

删除和迭代

ArrayList支持两种删除元素的方式

1. remove(int index) 按照下标删除
2. remove(Object o) 按照元素删除，删除第一个匹配到的元素。

public E remove(int index) {
        //数组下标越界检查
        rangeCheck(index);
        //修改次数自增1
        modCount++;
        //记录被删除的值
        E oldValue = elementData(index);
       // 记录将要从index后移动的多少个位数到前面，因为size是从0开始，index是从1开始所以需要减一
        int numMoved = size - index - 1;
        if (numMoved > 0)
            //从elementData的index+1处拷贝，拷贝到elementData数组中，从index处开始放置拷过来的元素，拷贝的长度是 numMoved
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // 最后一个元素赋值为null，帮助GC

        return oldValue;
    }

    /**
     根据值删除元素
     */
    public boolean remove(Object o) {
    //y因为ArrayList允许元素值为null，所以删除的时候遍历一次找到第一个是null的值，然后移除。
        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++)
            //这里是根据equals方法判断值是否相等，相等再根据索引删除
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    /*
     * Private remove method that skips bounds checking and does not
     * return the value removed.
     */
    private void fastRemove(int index) {
    //记录修改数加1
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; //最后元素赋值成null，有助于GC
    }

    /**
        移除集合中所有元素
     */
    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            //将集合中的每一个元素赋值为null
            elementData[i] = null;
        //集合元素的个数设置成0
        size = 0;
    }

• 新增时因为没有对null做校验所以可以新增null，删除的时候就需要对null值做判断了，按照值删除元素实际上还是根据值找到这个元素的索引，进行删除。比较的方法是通过equals方法。
• 某一个元素被删除后，ArrayList采用的是直接将这个元素后面的所有元素复制到原数组中，最后的一个元素的值设置成null，让JVM进行GC操作。

接下来看迭代

public ListIterator<E> listIterator(int index) {
    //如果索引越界直接抛异常IndexOutOfBoundsException，否则返回从指定下标开始的所有元素列表（按熟顺序），ListIterator接口继承了Iterator接口
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }

    /**
     * 返回列表中的列表迭代器按顺序返回，迭代器是fail-fast
     */
    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }

    /**
     * 以正确顺序返回元素列表的迭代器
     */
    public Iterator<E> iterator() {
        return new Itr();
    }

//ltr是ArrayList的内部类，实现了 Iterator接口,这里只是Itr的部分代码
 private class Itr implements Iterator<E> {
        int cursor;       // i迭代过程中，下一个元素的位置，默认从0开始
        int lastRet = -1; // 新增时表示上次迭代过程中，索引的位置；删除场景下是-1
        int expectedModCount = modCount;
        //期望修改的版本号=实际的修改版本号
        Itr() {}

        public boolean hasNext() {
        //判断下一个元素存不存在，只需知道下一个索引的下标是不是数组大小，如果不是返回true，如果是返回false
            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() {
        //当lastRet小于0，也就是说在多个线程操作时，直接将迭代器中的列表删完了，里面没有元素了，就会抛出IllegalStateException
            if (lastRet < 0)
                throw new IllegalStateException();
           //迭代过程中判断版本号有没有被修改，如果被修改抛出ConcurrentModificationException
           checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                //lastRet=-1防止重复删除
                lastRet = -1;
                //下次迭代时期望的版本号和实际的版本号一致
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
//版本号比较
final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

小结

• ArrayList底层是使用类似于动态数组实现的，默认构造方法初始化的容量是10，但是在没有指定容量大小时区add第一个元素时才会确定出数组的容量。
• 扩容时，扩容后的长度是扩容前的1.5倍
• 实现了RandomAccess接口，支持随机读写，get读取元素的性能较好
• 线程时不安全的，是因为自身的elementData、size、modCount在进行各种操作时，都没有加锁
• 新增(这里的新增默认是增加到尾部)和删除方法 的时间复杂度是O(1)

以上理解有误的地方欢迎指出，共同进步！