JDK源码走读之ArrayList

ArrayList其实就是动态数据，它封装了初始化、添加、删除、遍历等操作，并加入了泛型支持，下面我们从几个方面来分析一下ArrayList的实现。

定义

public class ArrayList<E> extends AbstractList<E>        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{    private static final long serialVersionUID = 8683452581122892189L;    private static final int DEFAULT_CAPACITY = 10;    private static final Object[] EMPTY_ELEMENTDATA = {};    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};    transient Object[] elementData; // non-private to simplify nested class access    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;}

添加元素

1.调用add(E e)方法添加元素，默认会添加到数据的最后，添加元素之前首先要确保当前数组有空间能够接纳新元素，如果空间不够则进行扩容

public boolean add(E e) {    // 确保数组有足够的空间接纳新元素        ensureCapacityInternal(size + 1);        elementData[size++] = e;        return true;}private void ensureCapacityInternal(int minCapacity) {    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);    }    ensureExplicitCapacity(minCapacity);}private void ensureExplicitCapacity(int minCapacity) {    modCount++;    // 如果数组长度不满足要求，则进行扩容，具体实现参考数据扩容    if (minCapacity - elementData.length > 0)        grow(minCapacity); }

2.调用把元素添add(int index, E element)方法把元素加到指定位置，具体实现如下

public void add(int index, E element) {    rangeCheckForAdd(index);    ensureCapacityInternal(size + 1);// 调用native方法在数据中间插入元素    System.arraycopy(elementData, index, elementData, index + 1,                     size - index);    elementData[index] = element;    size++;}

数组扩容

数组的最大长度为Integer.MAX_VALUE - 8 即2147483639，进行数据扩容时首先要确保新申请的数据长度不能超过该值，然后调用底层native方法开辟新数据，并把数据复制进去

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;private void grow(int minCapacity) {    int oldCapacity = elementData.length;    // 默认数组长度扩大为当前长度的1.5倍    int newCapacity = oldCapacity + (oldCapacity >> 1);    if (newCapacity - minCapacity < 0)        newCapacity = minCapacity;    // 确保数组最大长度不超过MAX_ARRAY_SIZE    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;}Arrays.copyOf(elementData, newCapacity)方法实现如下public static <T> T[] copyOf(T[] original, int newLength) {    return (T[]) copyOf(original, newLength, original.getClass());}public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {    // 判断数组类型是否匹配，如果不匹配则调用native方法开辟新数组    T[] copy = ((Object)newType == (Object)Object[].class)        ? (T[]) new Object[newLength]        // native方法        : (T[]) Array.newInstance(newType.getComponentType(), newLength);    // native方法    System.arraycopy(original, 0, copy, 0,                     Math.min(original.length, newLength));    return copy;}

删除元素

1.remove(int index)方法可以删除指定位置的元素，调用该方法会直接移除对应下边的元素，并对数据进行整理(调用System.arraycopy方法进行复制)，这样可以有效的减小对内存空间的占用，但是由于其需要整理内存，相对来说代价较大。

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);    // 释放引用，这样GC的时候就能被回收    elementData[--size] = null;     return oldValue;}

2.remove(Object o)移除数组中o元素，通过循环遍历定位到o元素，并进行移除。该方法没有直接进行内存整理，而是释放数据对元素的引用，这样在GC的时候就可以回收o元素，但是o对应的数据位置会被赋值为null，并不会被释放。

public boolean remove(Object o) {    // 循环超找元素，找到之后进行清理，并返回true    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++)            if (o.equals(elementData[index])) {                fastRemove(index);                return true;            }    }    return false;}

总结

1. 数据扩容需要调用底层重新开辟内存空间，并进行数据的移动，使用ArrayList在初始化的时候尽量指定合适的容量，以避免数据频繁扩容
2. 数据的默认大小是10，每次扩容变为原来的1.5倍，即15、22、33…..
3. ArrayList查询较快，时间复杂度为O(1)，（指定位置）添加元素和（指定位置）删除元素较慢平均时间复杂度为O(n)
4. 尽量避免频繁调用add(int index, E element)和remove(int index)方法，这两个方法会调用System.copy对内存进行整理，相对代价较大

5. ArrayList不是线程安全的，并发场景下可以使用vector替代

   注:以上源码为JDK1.8