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;

….
}

初始化

初始化的时候可以指定数组大小，系统会按照指定大小初
4000
始化数组；如果不指定大小则默认为空数组。

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;
}

总结

数据扩容需要调用底层重新开辟内存空间，并进行数据的移动，使用ArrayList在初始化的时候尽量指定合适的容量，以避免数据频繁扩容

数据的默认大小是10，每次扩容变为原来的1.5倍，即15、22、33…..

ArrayList查询较快，时间复杂度为O(1)，（指定位置）添加元素和（指定位置）删除元素较慢平均时间复杂度为O(n)

尽量避免频繁调用add(int index, E element)和remove(int index)方法，这两个方法会调用System.copy对内存进行整理，相对代价较大

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

注:以上源码为JDK1.8