源码解析之ArrayList

我用的是jdk1.8

ArrayList的底层实现是数组，因此与数组有许多相同的地方。可以根据下标查找到关键字，插入关键字可能需要后移其他元素（所以插入非常慢）。与数组不同的地方在于可以动态的分配内存。

下面是ArrayList中的定义的字段：

    //定义ArrayList初始化大小
    private static final int DEFAULT_CAPACITY = 10;
    //static共享的空数组，当调用无参数构造函数的时候默认给个空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //1.8之后加入。与EMPTY_ELEMENTDATA作用相似。static共享的空数组，当使用了默认初始化大小时使用，与EMPTY_ELEMENTDATA区别
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //真正的保存数据用的数据。说明其底层实现是一个Object数组
    transient Object[] elementData; // non-private to simplify nested class access
    //默认ArrayList的大小
    private int size;

定义了三个构造器：

    //构造器
    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;
    }

    //构造器：把一个Collection中的元素转为数组形式后，放到这个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;
        }
    }

数组一经设定就不可改变大小，而ArrayList 的核心就是动态的分配数组的大小，

什么时候会用到动态增加数组内存？当对象执行add方法时。

核心方法如下（主要看grow方法）：

    //如有必要，需要增加ArrayList实例的容量，以确保它至少能容纳由最小容量参数minCapacity指定的元素数量
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
    
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    //可以分配的最大数组大小。
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    //增加容量以确保它至少能容纳最小容量参数指定的元素数量。
    private void grow(int minCapacity) {
        // overflow-conscious code
        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;
    }

还有其他的一些方法，没什么特别要讲的。