jdk 8 ArrayList源码
前言
ArrayList可以说是日常开发中最常用到的一个数据结构了，今天我们开始撸一下它的源码。
整体结构
ArrayList的继承关系如下所示：
需要注意到ArrayList实现了RandomAccess这个接口，其源码如下：
public interface RandomAccess {
}
可以看到这个接口里并没有任何属性或者方法，那为什么还有实现呢？主要是为了做一个标记，用来表明实现该接口的类支持快速（通常是固定时间）随机访问。此接口允许算法更改其行为，从而在随机或连续访问列表时能够提供良好的性能。
ArrayList底层其实是一个数组，比较简单，如下所示：
ArrayList的特点如下：
- 允许
null值； - 有序，可根据索引快速访问；
- 非线程安全；
- 快速失败，若是在遍历过程中，对集合进行结构性修改（增，删），会导致快速失败(
fast-fial)，这也是为什么《阿里巴巴Java开发手册》中禁止ArrayList在循环时增删元素；
成员变量
//默认容量
private static final int DEFAULT_CAPACITY = 10;
//空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认空数组 无参构造时用到
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//元素数组 真正用于存储元素
transient Object[] elementData;
//数组最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//元素个数
private int size;
构造方法
//无参构造
public ArrayList() {
// 默认使用DEFAULTCAPACITY_EMPTY_ELEMENTDATA 此时大小为0
this.elementData = DEFAULTDEFAULTCAPACITY_EMPTY_ELEMENTDATACAPACITY_EMPTY_ELEMENTDATA;
}
//带有 capacity入参的构造方法
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//等于0是 使用EMPTY_ELEMENTDATA 此时大小为0
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
//集合作为入参的构造方法
public ArrayList(Collection<? extends E> c) {
//elementData 是保存数组的容器，默认为 null
elementData = c.toArray();
//如果给定的集合（c）数据有值
if ((size = elementData.length) != 0) {
//如果集合元素类型不是 Object 类型，我们会转成 Object
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 给定集合（c）无值，则默认空数组
this.elementData = EMPTY_ELEMENTDATA;
}
}
关于这几个构造函数需要注意的点：
ArrayList无参构造初始化时，默认大小数组是空数组，而不是常说的10，ArrayList也是懒加载，只有真正存放数据时才会去进行扩容；- 在使用集合作为入参的构造函数时，，当给定集合内的元素不是
Object类型时，默认会将其转换为Object类型；
常用方法
下面详细撸一下几个常用方法的源码
add(E e)
public boolean add(E e) {
//检测目前的数组是否还能继续存放元素，不够执行扩容，size 为当前数组的大小
ensureCapacityInternal(size + 1);
//直接赋值，线程不安全的
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
// 调用无参构造时进入该if分支
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//这也说明了，当使用无参构造时，第一次add时，数组会长度会由0增加到10
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//确保容积足够
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
// 更新modCount
modCount++;
//如果期望的最小容量大于目前数组的长度，那么就扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//扩容，并把现有数据拷贝到新的数组里面去
private void grow(int minCapacity) {
//当前数组的长度
int oldCapacity = elementData.length;
//新数组长度为1.5倍的旧长度
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果新数组长度小于期望的最小容量 那么新数组长度直接设为期望容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//如果新数组长度大于最大允许的数组长度 新数组容量设为Integer的最大值
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 通过复制进行扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
//private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
add(E e)的逻辑还是比较清晰和简单的：
- 先判断是否需要扩容，需要的话就进行扩容，否则直接赋值即可；
- 扩容时，新数组的长度为旧数组长度的1.5倍；
- 扩容时调用的
Arrays#copyOf方法其底层最后调用的是一个native方法，System#arraycopy； ArrayList中的数组的最大值是Integer.MAX_VALUE，超过该值时JVM不会再继续分配内存空间了；- 新增时，没有对入参做校验，因而
ArrayList允许为null；
add(int index, E e)
public void add(int index, E element) {
//检查下标是否越界
rangeCheckForAdd(index);
//检查是否需要扩容
ensureCapacityInternal(size + 1);
// 数组元素位置调整
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//索引位置处涉及值
elementData[index] = element;
//更新size
size++;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
没啥好分析的，看一下注释就行。
add(Collection<? extends E> c)
public boolean addAll(Collection<? extends E> c) {
//转为Object数组
Object[] a = c.toArray();
//获取集合长度
int numNew = a.length;
// 检查是否需要进行扩容
ensureCapacityInternal(size + numNew);
//将c添加到数组中
System.arraycopy(a, 0, elementData, size, numNew);
//更新size
size += numNew;
return numNew != 0;
}
get(int index)
public E get(int index) {
//检测下标是否越界
rangeCheck(index);
//直接返回索引位置处的数据
return elementData(index);
}
remove(int index)
public E remove(int index) {
//检测下标是否越界
rangeCheck(index);
// 更新modCount
modCount++;
//索引位置处的值
E oldValue = elementData(index);
// numMoved 表示删除 index 位置的元素后，需要从 index 后移动多少个元素到前面去
// 减 1 的原因，是因为 size 从 1 开始算起，index 从 0开始算起
int numMoved = size - index - 1;
if (numMoved > 0)
// 从 index +1 位置开始被拷贝，拷贝的起始位置是 index，长度是 numMoved
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//置为null 帮助gc
elementData[--size] = null; // clear to let GC do its work
// 返回旧值
return oldValue;
}
remove(Object o)
public boolean remove(Object o) {
// 如果o为null
if (o == null) {
// 正序遍历，将第一个null对象移除
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
// 否则的话遍历数组进行查找，然后删除
for (int index = 0; index < size; index++)
// 这里是根据 equals 来判断值相等的，相等后再根据索引位置进行删除
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
// 可以看出没有返回值的 remove(int index)
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
}
迭代器 Iterator
在使用ArrayList时我们经常需要遍历集合来完成某些操作，通常有两种方式，一种是直接使用foreach，一种是使用Iterator接口，但两种本质上是一样的，foreach底层实现还是Iterator接口。
Itr
Itr是ArryList中的一个私有内部类，实现了Iterator接口用以实现遍历。
private class Itr implements Iterator<E> {
...
}
成员变量
// 迭代过程中，下一个元素的位置，默认从 0 开始
int cursor;
// 新增场景：表示上一次迭代过程中，索引的位置；删除时置为 -1
int lastRet = -1;
// protected transient int modCount = 0;
// modCount是ArrayList的一个属性字段，表示数组实际的版本号
// expectedModCount 表示迭代过程中，期望的版本号；
int expectedModCount = modCount;
主要方法
迭代器主要就三个方法：
hasNext：是否还有下一个元素；next：下一个元素值；remove：删除当前迭代的值；
hasNext()
public boolean hasNext() {
// cursor 表示下一个元素的位置，size 表示实际大小
// 如果两者相等，说明已经没有元素可以迭代了，
// 如果不等，说明还可以进行迭代
return cursor != size;
}
next()
@SuppressWarnings("unchecked")
public E next() {
// 迭代过程中，判断版本号有无被修改
// 如果被修改，抛 ConcurrentModificationException 异常
checkForComodification();
//本次迭代过程中，元素的索引位置
int i = cursor;
//参数校验
if (i >= size)
throw new NoSuchElementException();
//获取存储元素的数组
Object[] elementData = ArrayList.this.elementData;
//参数校验
if (i >= elementData.length)
throw new ConcurrentModificationException();
// 下一次迭代时，元素的位置，为下一次迭代做准备
cursor = i + 1;
// 返回元素值 同时将lastRet设置为 i
return (E) elementData[lastRet = i];
}
next方法做了两件事：
- 是否还能继续迭代；
- 定位到当前迭代的值，并为下一次迭代做好准备；
checkForComodification()
// 检测 ArrayList 中的 modCount 和当前迭代器对象的 expectedModCount 是否一致
// 不等的话直接抛出异常
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
这个方法没啥好说的，就是检查ArrayList中的modCount和当前迭代器对象的 expectedModCount是否一致，不一样就抛出ConcurrentModificationException。
remove()
public void remove() {
// 如果上一次操作时，数组的位置已经小于 0 了，说明数组已经被删除完了
if (lastRet < 0)
throw new IllegalStateException();
// 迭代过程中，判断版本号有无被修改，
// 如果被修改，抛 ConcurrentModificationException 异常
checkForComodification();
try {
// 此处调用的是ArrayList的 remove(int index)
ArrayList.this.remove(lastRet);
// 设置下一个位置
cursor = lastRet;
// -1 表示元素已经被删除，这里也防止重复删除
lastRet = -1;
// 删除元素时 modCount 的值已经发生变化，在此赋值给 expectedModCount
// 这样下次迭代时，两者的值是一致的了
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
需要注意的点是：
lastRet= -1 的操作目的，是防止重复删除操作;- 删除元素成功，数组当前
modCount就会发生变化，这里会把expectedModCount更新为modCount的值，下次迭代时两者的值就会一致了；
ListItr
ListItr是Itr的子类，除了基本的三个方法之外，还额外实现了一些其他的方法。我们都知道，在遍历集合时，若是对集合结构进行修改则会触发fast-fail机制，但若是我们的确有这个需求，一边遍历一边修改集合的结构，那怎么办呢？答案就在ListItr中的add方法中。
add(E e)
public void add(E e) {
//迭代过程中，判断版本号有无被修改，有被修改，抛 ConcurrentModificationException 异常
checkForComodification();
try {
//获取当前遍历到的位置
int i = cursor;
//插入到数组中
ArrayList.this.add(i, e);
//再向下移动一个位置 因而本次遍历过程中访问不到这个元素 只能在下一次遍历中才能访问
cursor = i + 1;
//更新lastRet
lastRet = -1;
// 添加元素时 modCount 的值已经发生变化，在此赋值给 expectedModCount
// 这样下次迭代时，两者的值是一致的了
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
使用add这个方法在遍历时添加时，本次遍历是访问不到添加的那个元素的，只能在下一次遍历时才能访问，保证了本次遍历的正确性，从而防止出现fast-fail。
其他方法
ListItr还实现了ListIterator这个接口，因而还可以前向遍历，这里只给出源码，简单看一下就行。
//判断是否还有前一个元素
public boolean hasPrevious() {
return cursor != 0;
}
//下个元素的索引
public int nextIndex() {
return cursor;
}
//前一个元素的索引
public int previousIndex() {
return cursor - 1;
}
//迭代时，前一个元素的值
@SuppressWarnings("unchecked")
public E previous() {
//校验modCount
checkForComodification();
//前一个位置索引
int i = cursor - 1;
if (i < 0)//参数校验
throw new NoSuchElementException();
//实际存储数据的数组
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)//参数校验
throw new ConcurrentModificationException();
//更新cursor
cursor = i;
//返回当前迭代的值，并设置 lastRet
return (E) elementData[lastRet = i];
}
总结
结合JDK8 ArrayList源码解析P1和本篇文章一起总结一下ArrayList的特点，如下：
- 底层是动态数组，默认大小为10，扩容时每次都是当前数组长度的1.5倍；
- 使用无参构造或者
capacity=0的有参构造时，ELEMENTDATA都是空数组，只有在第一次添加元素时才去扩容； - 扩容主要方法为
grow(int minCapacity)，不支持缩容； - 允许元素为
null； - 实现
RandomAccess接口，支持随机访问，平均时间复杂度为O(1)； - 底层是数组，所以增加和删除元素过程时，效率低下，平均时间复杂度为
O(n)；
