深耕JavaSe - ArrayList底层源码分析

public class ArrayList<E>  extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable {

}

（1）ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，不像数组一旦初始化长度就不可被改变

（2）ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。

（3）ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问，实现了Cloneable接口，能被克隆。

增删慢：每次删除元素，都需要更改数组的长度，拷贝以及移动元素的位置

查询快：由于数组在内存中是一块连续的空间，因此可以根据索引快速获取某个位置上的元素。

1. 属性

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

/**
 * 空数组，如果传入的容量为0时使用
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 空数组，传传入容量时使用，添加第一个元素的时候会重新初始为默认容量大小
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 存储元素的数组
 */
transient Object[] elementData;

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

（1）DEFAULT_CAPACITY ：默认容量为10，也就是通过new ArrayList()创建时的默认容量。

（2）EMPTY_ELEMENTDATA：空的数组，这种是通过new ArrayList(0)创建时用的是这个空数组。

（3）DEFAULTCAPACITY_EMPTY_ELEMENTDATA：也是空数组，这种是通过new ArrayList()创建时用的是这个空数组，与EMPTY_ELEMENTDATA的区别是在添加第一个元素时使用这个空数组的会初始化为DEFAULT_CAPACITY（10）个元素。

（4）elementData：真正存放元素的地方

（5）size：真正存储元素的个数，而不是elementData数组的长度。

2. 构造函数

2.1 ArrayList()

不传初始容量，初始化为DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组，会在添加第一个元素的时候扩容为默认的大小，即10。

/**
 * 空参数构造函数
 *
 * 不传初始容量，初始化为DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组，会在添加第一个元素的时候扩容为默认的大小，即10。
 */
public ArrayList() {
    // 如果没有传入初始容量，则使用空数组 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    // 使用这个数组是在添加第一个元素的时候会扩容到默认容量大小10
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
} 

2.2 ArrayList(int initialCapacity)

传入初始容量，如果大于0就初始化elementData为对应大小，如果等于0就使用EMPTY_ELEMENTDATA空数组，如果小于0抛出异常。

/**
 * 带参构造函数
 *
 * 传入初始容量，如果大于0就初始化elementData为对应大小，如果等于0就使用EMPTY_ELEMENTDATA空数组，如果小于0抛出异常。
 * @param initialCapacity 初始容量大小
 */
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        // 如果传入的初始容量大于0，就新建一个长度为initialCapacity的数组赋值给elementData存储元素
        this.elementData = new Object[initialCapacity];
    } else {
        // 如果传入的初始容量小于0，抛出异常
        if (initialCapacity != 0) {
            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
        }
        // 如果传入的初始容量等于0，使用空数组EMPTY_ELEMENTDATA
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

2.3 ArrayList(Collection<? extends E> c)

传入集合并初始化elementData，这里会使用拷贝把传入集合的元素拷贝到elementData数组中，如果元素个数为0，则初始化为EMPTY_ELEMENTDATA空数组。

/**
 * 带参构造函数
 *
 * 传入集合并初始化elementData，这里会使用拷贝把传入集合的元素拷贝到elementData数组中，如果元素个数为0，则初始化为EMPTY_ELEMENTDATA空数组。
 * @param c 集合
 */
public ArrayList(Collection<? extends E> c) {
    // 将集合转为数组并赋值给elementData
    this.elementData = c.toArray();
    // size代表数组中元素的个数
    if ((this.size = this.elementData.length) != 0) {
        // 检查c.toArray()返回的是不是Object[]类型，如果不是，重新拷贝成Object[].class类型
        if (this.elementData.getClass() != Object[].class) {
            this.elementData = Arrays.copyOf(this.elementData, this.size, Object[].class);
        }
    } else {
        // 如果c是空集合，则将elementData初始化为空数组EMPTY_ELEMENTDATA
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

3. 添加元素

3.1 add(E e)

添加元素到末尾，平均时间复杂度为O(1)。

/**
 * 添加元素到末尾，平均时间复杂度为O(1)。
 *
 * @param e 元素
 * @return 是否添加成功
 */
public boolean add(E e) {
    ++this.modCount;
    // 添加一个元素e到数组elementData中
    this.add(e, this.elementData, this.size);
    return true;
}

（1）检查是否需要扩容；

（2）如果elementData等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA则初始化容量大小为DEFAULT_CAPACITY；

（3）新容量是老容量的1.5倍（oldCapacity + (oldCapacity >> 1)），如果加了这么多容量发现比需要的容量还小，则以需要的容量为准；

（4）创建新容量的数组并把老数组拷贝到新数组；

3.2 add(int index, E element)

添加元素到指定位置，平均时间复杂度为O(n)。

/**
 * 添加元素到指定位置，平均时间复杂度为O(n)。
 *
 * @param index 索引
 * @param element 要添加的元素
 */
public void add(int index, E element) {
    // 参数合法性校验
    this.rangeCheckForAdd(index);
    ++this.modCount;
    int s;
    // 定义一个数组变量elementData
    Object[] elementData;
    // 如果集合中元素的个数与存储元素的elementData数组大小相等，就说明无法再向elementData数组中添加元素，需要对elementData数组进行扩容
    if ((s = this.size) == (elementData = this.elementData).length) {
        elementData = this.grow();
    }

    /**
     * 将elementData数组中从index到末尾的元素 复制粘贴到index+1到末尾处，把index位置空出来，用以在该处添加新的元素
     *
     * 源数组：elementData
     * 源数组要复制的起始位置：index
     * 目的数组：elementData
     * 目的数组要放置的起始位置：index + 1
     * 复制的长度：s - index
     */
    System.arraycopy(elementData, index, elementData, index + 1, s - index);
    // 将元素添加到index处
    elementData[index] = element;
    // 添加一个元素后，size的大小加1
    this.size = s + 1;
}

/**
 * 校验参数index的合法性
 *
 * @param index
 */
private void rangeCheckForAdd(int index) {
    if (index > this.size || index < 0) {
        throw new IndexOutOfBoundsException(this.outOfBoundsMsg(index));
    }
}

private Object[] grow(int minCapacity) {
    // 创建一容量大小为newCapacity的新数组，将数组elementData中的元素拷贝该数组中，并将该数组重新赋值给elementData
    return this.elementData = Arrays.copyOf(this.elementData, this.newCapacity(minCapacity));
}

private Object[] grow() {
    //扩容所需要的最小容量minCapacity为：size+1
    return this.grow(this.size + 1);
}

/**
 * 计算数组扩容后的容量大小
 *
 * @param minCapacity
 * @return 新容量
 */
private int newCapacity(int minCapacity) {
    // 数组的旧容量
    int oldCapacity = this.elementData.length;
    // 新容量为旧容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 如果新容量newCapacity比需要的最小容量minCapacity还小
    if (newCapacity - minCapacity <= 0) {
        if (this.elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            // 如果elementData是空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，将elementData扩容到初始容量10
            return Math.max(10, minCapacity);
        } else if (minCapacity < 0) {
            throw new OutOfMemoryError();
        } else {
            // 否则，需要的容量minCapacity为准
            return minCapacity;
        }
    } else {
        return newCapacity - 2147483639 <= 0 ? newCapacity : hugeCapacity(minCapacity);
    }
}

/**
 * 添加元素到末尾
 *
 * @param e 元素
 * @param elementData 存放集合元素的数组
 * @param s 集合中元素的个数
 */
private void add(E e, Object[] elementData, int s) {
    // 如果集合中元素的个数size与数组elementData的大小相等，说明elementData不足以存放一个新的元素，需要扩容
    if (s == elementData.length) {
        elementData = this.grow();
    }
    // 将元素添加到数组的末尾
    elementData[s] = e;
    // 集合中元素的个数size+1
    this.size = s + 1;
}

（1）检查索引是否越界；

（2）检查是否需要扩容；

（3）把插入索引位置后的元素都往后挪一位；

（4）在插入索引位置放置插入的元素；

（5）大小size加1；

3.3 addAll(Collection<? extends E> c)

求两个集合的并集。

/**
  * 将集合c中所有元素添加到当前ArrayList中
  *
  * @param c 集合
  * @return 是否添加成功
*/
public boolean addAll(Collection<? extends E> c) {
    // 将集合c转为数组
    Object[] a = c.toArray();
    ++this.modCount;
    int numNew = a.length;
    // 如何集合为空，添加失败
    if (numNew == 0) {
        return false;
    } else {
        Object[] elementData;
        int s;
        // 如果数组elementData的大小-数组中元素的个数 > newNew，需要扩容
        if (numNew > (elementData = this.elementData).length - (s = this.size)) {
            elementData = this.grow(s + numNew);
        }
        // 将原数组中index为[0-numNew]中的元素，赋值到数组elementData中index为[s,s+numNew]的位置
        System.arraycopy(a, 0, elementData, s, numNew);
        // 将集合中元素的个数设置为s + numNew
        this.size = s + numNew;
        return true;
    }
}

（1）拷贝c中的元素到数组a中；

（2）检查是否需要扩容；

（3）把数组a中的元素拷贝到elementData的尾部；

4. 删除元素

4.1 remove(int index)

删除指定索引位置的元素，时间复杂度为O(n)。

/**
 * 删除指定索引位置的元素，时间复杂度为O(n)。
 * @param index 索引
 * @return
 */
public E remove(int index) {
    // 检查index是否越界
    Objects.checkIndex(index, this.size);
    Object[] es = this.elementData;
    // 获取index位置处的元素
    E oldValue = (E) es[index];
    // 删除index位置处的元素
    this.fastRemove(es, index);
    // 返回旧值
    return oldValue;
}

private void fastRemove(Object[] es, int i) {
    ++this.modCount;
    int newSize;
    // 如果index不是最后一位，则将index之后的元素往前挪一位
    if ((newSize = this.size - 1) > i) {
        System.arraycopy(es, i + 1, es, i, newSize - i);
    }
    // 将最后一个元素删除，帮助GC
    es[this.size = newSize] = null;
}

/**
 * 获取指定索引位置的元素，时间复杂度为O(1)。
 *
 * @param index 索引
 * @return 索引index处的元素
 */
public E get(int index) {
    // 判断index是否越界
    Objects.checkIndex(index, this.size);
    // 返回数组index位置的元素
    return this.elementData(index);
}

/**
* 返回数组index位置处的元素
* 
* @param index 索引
* @return 数组索引index处的元素
*/
E elementData(int index) {
	return this.elementData[index];
} 

（1）检查索引是否越界；

（2）获取指定索引位置的元素；

（3）如果删除的不是最后一位，则其它元素往前移一位；

（4）将最后一位置为null，方便GC回收；

（5）返回删除的元素。

fastRemove(int index)相对于remove(int index)少了检查索引越界的操作，可见jdk将性能优化到极致。

4.2 remove(Object o)

删除指定元素值的元素，时间复杂度为O(n)。

/**
 * 删除指定元素值的元素，时间复杂度为O(n)。
 *
 * @param o 指定元素
 * @return true/false
 */
public boolean remove(Object o) {
    Object[] es = this.elementData;
    int size = this.size;
    int i = 0;
    if (o == null) {
        // 如果要删除的元素为null，则以null进行比较，使用==
        while(true) {
            if (i >= size) {
                return false;
            }

            if (es[i] == null) {
                break;
            }

            ++i;
        }
    } else {
        // 如果要删除的元素不为null，则进行比较，使用equals()方法
        while(true) {
            if (i >= size) {
                return false;
            }

            if (o.equals(es[i])) {
                break;
            }

            ++i;
        }
    }
    // 将找到的元素删除
    this.fastRemove(es, i);
    return true;
}

private void fastRemove(Object[] es, int i) {
    ++this.modCount;
    int newSize;
    if ((newSize = this.size - 1) > i) {
        // 如果index不是最后一位，则将index之后的元素往前挪一位
        System.arraycopy(es, i + 1, es, i, newSize - i);
    }
    // 将最后一个元素删除，帮助GC
    es[this.size = newSize] = null;
}

（1）找到第一个等于指定元素值的元素；

（2）快速删除；