ArrayList源码详解

ArrayList UML类图

ArrayList 概述

ArrayList 是实现 List 接口的动态数组，所谓动态就是它的大小是可变的。实现了所有可选列表操作，并允许包括 null 在内的所有元素。

除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

每个 ArrayList 实例都有一个容量，该容量是指用来存储列表元素的数组的大小。默认初始容量为 10。随着 ArrayList 中元素的增加，它的容量也会不断的自动增长。在每次添加新的元素时，ArrayList 都会检查是否需要进行扩容操作，扩容操作带来数据向新数组的重新拷贝，所以如果我们知道具体业务数据量，在构造 ArrayList 时可以给 ArrayList 指定一个初始容量，这样就会减少扩容时数据的拷贝问题。当然在添加大量元素前，应用程序也可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量，这可以减少递增式再分配的数量。

请注意，此实现不同步。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。所以为了保证同步，最好的办法是在创建时完成，以防止意外对列表进行不同步的访问：
List list = Collections.synchronizedList(new ArrayList(…));

ArrayList 源码分析

几个比较重要的字段

//默认初始容量
private static final int DEFAULT_CAPACITY = 10;
//共享的空数组实例。
private static final Object[] EMPTY_ELEMENTDATA = {};
//存放元素的数组
private transient Object[] elementData;

transient是个关键字，这个关键字的意思是：transient修饰的变量将不进行序列化
详解：http://blog.csdn.net/u013207877/article/details/52572975
EMPTY_ELEMENTDATA 和elementData字段的作用将在构造方法里体现

构造方法

    //初始化一个默认为10的容量
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }
    //可以指定初始化容量，指定初始容量为负时，则抛出异常
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }
    //使用集合类对象初始化ArrayList,底层使用数组copy方式。
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        //jdk源码注释： c.toArray might (incorrectly) not return Object[] (see 6260652)
        //意思是：c.toArray可能（错误）不返回Object[]  see 6260652 这个编号代表JDK bug库中的编号
        //原因:https://www.cnblogs.com/cmdra/p/5901793.html
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

add方法

boolean add(E e)

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // jdk源码注释：Increments modCount!!。 自增修改次数！！
        elementData[size++] = e;
        return true;
    }

    //这个方法是 确保内部的容量大小可以存储元素
    private void ensureCapacityInternal(int minCapacity) {
        //if语句判断的是，当前是否第一次添加元素，如果是的话，则把最小容量(minCapacity)赋值为10
        if (elementData == EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//DEFAULT_CAPACITY的值一定是10，final修饰了
        }
        ensureExplicitCapacity(minCapacity);
    }
    //这个方法是 确保明确增加多少容量
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//防止迭代的时候有其他线程进行结构的改变。

        //如果最小的列表容量跟当前数组的长度相减大于0的话，那么需要进行扩容；
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //这个方式是进行容量扩容
    private void grow(int minCapacity) {
        //oldCapacity 旧的容量
        int oldCapacity = elementData.length;
        //newCapacity 新的容量   (oldCapacity >> 1)这个表达式的意思是oldCapacity*1.5
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果if语句成立，当minCapacity小于0则会抛出内存溢出异常,当minCapacity大于0，则newCapacity=Integer.MAX_VALUE;            
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //当前元素添加到新的数组，并进行数组扩容。
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    //数组扩容并把元素添加到新的数组里面
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        //判断类型是否一致，如果不一致，则重新实例化（Array.newInstance()）数组
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
                //复制数组，将原数组从0索引开始复制，复制到新的数组，从0索引位置开始复制，复制Math.min(original.length, newLength)个
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

void add( int index, E element)方法

    //指定的位置插入指定的元素,指定的位置必须小于等于size
    public void add(int index, E element) {
        //范围检查,指定的索引不能超过当前的容量值，也不能小于0
        rangeCheckForAdd(index);
        //确保容量内部有位置存储
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将当前数组从指定的索引开始复制，复制到指定索引后面的一个位置
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
    //检查传入的index值是否越界。
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

Remove

    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; // JVM会清除
        //返回移除的元素
        return oldValue;
    }

get(int index)

    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

trimToSize

底层数组的容量调整为当前列表保存的实际元素的大小的功能

    public void trimToSize() {
        modCount++;
        //如果时间大小小于缓冲区容量的长度，则进行数组复制。
        if (size < elementData.length) {
            elementData = Arrays.copyOf(elementData, size);
        }
    }

Iterator迭代器

    private class Itr implements Iterator<E> {
        int cursor;        // 返回下一个元素的索引
        int lastRet = -1; // 返回的最后一个元素的索引；如果没有，则为1
        int expectedModCount = modCount;

        public boolean hasNext() {
            //第一次调用，因为变量的初始化，那么cursor的值为0，
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            //检查是否有被并发修改
            checkForComodification();
            //将光标赋值给i
            int i = cursor;
            //如果光标值大于等于集合个数的话，则抛出异常
            if (i >= size)
                throw new NoSuchElementException();
            //获取集合内的元素
            Object[] elementData = ArrayList.this.elementData;
            //判断是否有其他线程进行修改
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            //光标加1
            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();
            }
        }

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