ArrayList源码分析及底层原理

源码

构造器：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;


    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;


    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};


    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};


    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access


    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    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);
        }
    }
//创建空数组，第一次添加元素时设置数组大小为10
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // defend against c.toArray (incorrectly) not returning Object[]
            // (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

添加元素

public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
    return true;
}

private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
    //当数组用完，调用动态扩容函数
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

private Object[] grow() {
    return grow(size + 1);
}

private Object[] grow(int minCapacity) {
//动态扩容：设置好新数组长度，为原数组1.5倍，然后将原数组拷贝到新数组，原数组垃圾回收
    return elementData = Arrays.copyOf(elementData,
                                       newCapacity(minCapacity));
}

private int newCapacity(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity <= 0) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return minCapacity;
    }
    return (newCapacity - MAX_ARRAY_SIZE <= 0)
        ? newCapacity
        : hugeCapacity(minCapacity);
}

ArrayList底层是由动态数组实现的。动态数组就是长度不固定，随着数据的增多而变长。当实例化ArrayList时（比如：List intList = new ArrayList<>();），如果不指定它的长度，则默认为10
如果当添加的元素超过当前数组的长度时，它会新创建一个数组，长度为当前数组的1.5倍，然后将当前数组的元素复制到新的数组，当前数组的内存被释放

动态数组

• 是指当数组容量不足以存放新的元素时，会创建新的数组，然后把原数组中的内容复制到新数组。

扩容机制

1. jdk1.8的扩容算法：newCapacity = oldCapacity + ( oldCapacity >> 1 ) ; //oldCapacity >> 1 移位运算，此处相当于oldCapacity除以2，但是 >> 这种写法更加高效
2. 参数介绍：newCapacity 是扩容后的容量大小，oldCapacity 是扩容前的大小 ，新容量为旧容量1.5倍

add(element) 流程

1. 判断当前数组是否为空，如果是则创建长度为 10（默认）的数组，因为 new ArrayList 的时是没有初始化；
2. 判断是否需要扩容，如果当前数组的长度加 1（即 size+1）后是否大于当前数组长度，则进行扩容 grow()；
3. 最后在数组末尾添加元素，并 size+1。

grow() 流程：

1. 创建新数组，长度扩大为原数组的 1.5 倍；
2. 如果扩大 1.5 倍还是不够，则根据实际长度来扩容，比如 addAll() 场景
3. 将原数组的数据使用 Arrays.copyof 复制到新数组中。

注意事项：

1. new ArrayList 创建对象时，如果没有指定集合容量则初始化为 0；如果有指定，则按照指定的大小初始化；
2. 扩容时，先将集合扩大 1.5 倍，如果还是不够，则根据实际长度来扩容，保证都能存储所有数据，比如 addAll() 场景。
3. 如果新扩容后数组长度大于（Integer.MAX_VALUE-8），则抛出 OutOfMemoryError。