ArrayList源码分析
以下代码都是基于java8的版本
ArrayList简介
源码：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//......
}
ArrayList与Collection的关系如下图，实现代表继承，虚线代表实现接口：
- ArrayList是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List，RandomAccess，Cloneable，java.io.Serializable这些接口。
- ArrayList继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
- ArrayList实现了RandmoAccess接口，即提供了随机访问的功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
- ArrayList实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
- ArrayList实现了java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。
注意：==ArrayList中的操作不是线程安全的！==所以，建议在单线程中使用，多线程情况下可以选择
CopyOnWriteArrayList或者使用Collections.synchronizedList方法将其包装成一个线程安全的List。
ArrayList的API
// Collection中定义的API
boolean add(E object)
boolean addAll(Collection<? extends E> collection)
void clear()
boolean contains(Object object)
boolean containsAll(Collection<?> collection)
boolean equals(Object object)
int hashCode()
boolean isEmpty()
Iterator<E> iterator()
boolean remove(Object object)
boolean removeAll(Collection<?> collection)
boolean retainAll(Collection<?> collection)
int size()
<T> T[] toArray(T[] array)
Object[] toArray()
// AbstractCollection中定义的API
void add(int location, E object)
boolean addAll(int location, Collection<? extends E> collection)
E get(int location)
int indexOf(Object object)
int lastIndexOf(Object object)
ListIterator<E> listIterator(int location)
ListIterator<E> listIterator()
E remove(int location)
E set(int location, E object)
List<E> subList(int start, int end)
// ArrayList新增的API
Object clone()
void ensureCapacity(int minimumCapacity)
void trimToSize()
void removeRange(int fromIndex, int toIndex)
ArrayList的属性
ArrayList的主要属性如下代码所示:
//序列化id
private static final long serialVersionUID = 8683452581122892189L;
//容器默认初始化大小
private static final int DEFAULT_CAPACITY = 10;
//一个空对象
private static final Object[] EMPTY_ELEMENTDATA = {};
//一个空对象，如果使用默认构造函数创建ArrayList，则默认对象内容是该值
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//ArrayList存放对象的容器，后面的添加、删除等操作都是基于该属性来进行操作
transient Object[] elementData;
//当前列表已使用的长度
private int size;
//数组最大长度（2147483639），
//这里为什么是Integer.MAX_VALUE - 8是因为有些虚拟机在数组中保留了一些头部信息，防止内存溢出
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//这个是从AbstractList继承过来的，代表ArrayList集合修改的次数
protected transient int modCount = 0;
构造函数
无参构造函数
如果不传入参数，则使用默认无参构造方法创建ArrayLisy对象，如下：
/**
* Constructs an empty list with an initial capacity of ten.
构造一个初始容量为 10 的空列表
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
**注意：此时我们创建的ArrayList对象中的elementData中的长度是0，size是0，当进行第一次add的时候，elementDate将会变成默认的长度：10。**后文会讲到
带int类型的构造函数
如果传入参数，则代表指定ArrayList的初始数组长度；传入参数如果是大于0，则使用用户的参数初始化；如果参数等于0，则用内部的空对象EMPTY_ELEMENTDATA的地址直接赋值给elementData；否则抛出异常，如下：
/**
构造一个具有指定初始容量的空列表。
参数：initialCapacity – 列表的初始容量
抛出：IllegalArgumentException – 如果指定的初始容量为负
*/
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);
}
}
带Collection对象的构造函数
- 将Collection对象转换成数组，然后将数组的地址赋值给elementData。
- 更新size的值，如果size的值等于0直接将内部空对象EMPTY_ELEMENTDATA的地址赋值给elementData。
- 如果size的值大于0，则执行Arrays.copy方法，把Collection对象的内容copy(可以理解为深拷贝)到elementData中，并且这些元素是按照该collection的迭代器返回它们的顺序排列的。
/**
按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。
参数：c – 其元素将被放入此列表的集合
抛出：NullPointerException – 如果指定的集合为空
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
System.arraycopy和Arrays.copy
这里介绍下System.arraycopy和Arrays.copy方法，因为后分析源码时会经常用到。
System.arraycopy方法：它就是从指定的源数组将元素中复制到目标数组，复制从指定的位置开始，到设定的复制长度结束，然后从目标数组的指定起始位置依次插入。最终会调用native本地方法。
// src 源数组
// srcPos 源数组要复制的起始位置
// dest 要赋值到的目标数组
// destPos 目标数组放置的起始位置
// length 复制的长度
// 使用了native关键字，说明调用的是其他语言写的底层函数
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
Arrays.copy方法：它新建了一个数组并且将原数组的内容拷贝到长度为newLength的新数组中，并且返回该新数组。
// original 要复制的数组
// newLength 要返回副本的长度
// newwType 要返回的副本类型
// 内部调用了System.arraycopy方法
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
区别：
- System.arraycopy
需要目标数组，将原数组拷贝到目标数组里，而且可以选择拷贝的起点和长度以及放入新数组中的位置。 - Arrays.copyof是系统
自动在内部新建一个数组最为目标数组，调用System.arraycopy将原数组的内容拷贝到长度为newLength的目标数组中，并返回新建的目标数组。
添加元素
ArrayList提供了add(E e)、add(int index, E element)、addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)、set(int index, E element)这个五个方法来实现ArrayList增加。
add(E e)
/**
将指定的元素附加到此列表的末尾。
参数：e - 要附加到此列表的元素
返回：true （由Collection.add指定）
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
接下来我们看ensureCapacityInternal方法，以及它内部调用的方法。
/**
*这个方式是判断当前数组是否是个空数组，
*如果是就返回默认长度10，否则就返回size+1;
*也就是说如果你是用无参构造函数初始化ArrayList，那么在第一次调用add方法时，默认长度会变成10
*/
private void ensureCapacityInternal(int minCapacity) {
// 1.这个方式是判断当前数组是否是个空数组
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 2.如果是就返回默认长度10
//也就是说如果用 new ArrayList<>()那么，在第一次调用add方法时，默认长度会变成10
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
接下来我们看ensureExplicitCapacity方法，以及它内部调用的方法。
// 记录修改次数和判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
// 这个方法首先将集合修改次数加1，modCount字段在AbstractList类里，
modCount++;
// overflow-conscious code
//然后判断数组的长度是否能存入下一个元素
if (minCapacity - elementData.length > 0)
// 如果长度不够会调用grow方法进行扩容
grow(minCapacity);
}
接下来我们看grow方法，以及它内部调用的方法。
//这个方法首先定义数组新的长度为原来数组长度的1.5倍，
//如果新长度减去所需数组的最小长度小于0，那么新长度就等于所需数组最小长度；
//再下面的判断是如果新长度大于MAX_ARRAY_SIZE(ArrayList内部定义MAX_ARRAY_SIZE的值是：2147483639)就调用
//hugeCapacity方法，最后调用Arrays.copyOf将扩容后的新数组地址赋值给elementData
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//这个方法首先定义数组新的长度为原来数组长度的1.5倍，
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果新长度减去所需数组的最小长度小于0，那么新长度就等于所需数组最小长度；
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//再下面的判断新的长度是否大于MAX_ARRAY_SIZE(ArrayList内部定义MAX_ARRAY_SIZE的值是：2147483639)
if (newCapacity - MAX_ARRAY_SIZE > 0)
// 调用hugeCapacity方法，设置新的长度
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
// 最后调用Arrays.copyOf将扩容后的新数组地址赋值给elementData
elementData = Arrays.copyOf(elementData, newCapacity);
}
接下来我们看hugeCapacity方法，以及它内部调用的方法。
// 设置新的长度
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
// 如果扩容长度超过MAX_ARRAY_SIZE，则设置长度为Integer.MAX_VALUE
// 但不是百分百成功的，这取决于虚拟机。
//（如果我们在某些虚拟机上可以避免OutOfMemory，我们将另外分配Integer.MAX_VALUE，
// 如果你很幸运（取决于虚拟机），我们将成功）
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
最后总结一下add方法的逻辑：
- 确保数组已使用长度（size）加1后可以存入下一个元素。
- 修改次数modCount标识自增1，如果当前数组元素个数+1后大于当前数组长度，则调用grow方法，扩容数组，grow方法会将当前数组的容量变为原来容量的1.5倍。
- 确保新加的元素有地方存储后，则将新元素添加到位于size++的位置上。
- 返回添加成功的布尔值。
add(int index, E element)
这个方法和上面的add类似，该方法可以按照元素的位置，指定新元素位置插入。
public void add(int index, E element) {
//1.判断索引位置是否正确
rangeCheckForAdd(index);
//2.扩容检测
ensureCapacityInternal(size + 1); // Increments modCount!!
//3.对源数组进行复制处理（位移），从index + 1到size - index
//相当于index和后面的元素往后移动一位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//4.在指定的位置赋值
elementData[index] = element;
size++;
}
接下来我们看rangeCheckForAdd方法，以及它内部调用的方法。
// 该方法首先调用rangeCheckForAdd方法判断指定的位置小于当前数组的长度并且大于0，否则抛出异常。
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
第二步调用的ensureCapacityInternal方法和上面的add方法逻辑一样。
第三步调用System.arraycopy方法把指定下标以及后面的元素全部往后移一位。
最后将新的元素放到指定位置（index）上，并将size+1。
addAll(Collection<? extends E> c)
//按照指定的Collection迭代器所返回的顺序，依次插入到列表尾部。
public boolean addAll(Collection<? extends E> c) {
// 将c转换为数组
Object[] a = c.toArray();
int numNew = a.length;
//扩容处理，大小为size + numNew
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
该方法首先传过来的Collection集合转换为数组，然后做扩容处理，接着使用System.arraycopy把转换后的数组复制到列表尾部。
addAll(int index, Collection<? extends E> c)
public boolean addAll(int index, Collection<? extends E> c) {
//判断索引位置是否正确
rangeCheckForAdd(index);
// 将c转换为数组
Object[] a = c.toArray();
int numNew = a.length;
//扩容处理，大小为size + numNew
ensureCapacityInternal(size + numNew); // Increments modCount
//如果插入索引小于列表长度，则将当前索引等于index和大于index的元素往后移numMoved个位置
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
//将数组添加到列表尾部
System.arraycopy(a, 0, elementData, index, numNew);
//更新列表长度
size += numNew;
return numNew != 80;
}
set(int index, E element)
public E set(int index, E element) {
//判断插入位置是否正确，如果大于列表长度会抛出异常
rangeCheck(index);
//获取插入位置的当前元素
E oldValue = elementData(index);
//将新的元素替换当前插入位置的元素
elementData[index] = element;
//返回插入位置老的值
return oldValue;
}
接下来我们看rangeCheck方法，以及它内部调用的方法。
// 判断索引位置是否正确
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
接下来我们看elementData方法，以及它内部调用的方法。
E elementData(int index) {
return (E) elementData[index];
}
删除元素
ArrayList提供了外界remove(int index)、remove(Object o)、removeAll(Collection<?> c)、clear()四个方法进行元素的删除。
remove(int index)
/**
移除此列表中指定位置的元素。 将任何后续元素向左移动（从它们的索引中减去一个）。
参数：index – 要删除的元素的索引
返回：从列表中删除的元素
抛出：IndexOutOfBoundsException –
*/
public E remove(int index) {
//判断删除位置是否正确，如果大于列表长度会抛出异常
rangeCheck(index);
//将集合修改次数加1
modCount++;
//获取当前删除位置上的元素
E oldValue = elementData(index);
//判断是否删除的是最后一个元素，
int numMoved = size - index - 1;
if (numMoved > 0)
// 将删除位置后方的元素向左移numMoved个位置
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将列表最后的元素置为null，等待垃圾收集器收集
elementData[--size] = null; // clear to let GC do its work
//返回删除位置老的值
return oldValue;
}
删除主要流程：检查索引是否正确，取到索引对应的数值，将数组复制缩容，最后位置置为null，返回刚刚索引对应的数值。
remove(Object o)
/**
从此列表中删除第一次出现的指定元素（如果存在）。 如果列表不包含该元素，则它保持不变。 更正式地，删除具有最低索引i的元素，使得(o==null ? get(i)==null : o.equals(get(i))) （如果这样的元素存在）。 如果此列表包含指定的元素（或等效地，如果此列表因调用而更改），则返回true 。
参数：o - 要从此列表中删除的元素（如果存在）
返回：如果此列表包含指定的元素，则为tru
*/
public boolean remove(Object o) {
//因为ArrayList允许存在null，所以需要进行null判断
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;
}
接下来我们看fastRemove方法，以及它内部调用的方法。
/**
该方法和remove(int index) 基本一样，只不过该方法跳过边界检查并且不返回移除的值，而且是私有方法
*/
private void fastRemove(int index) {
//将集合修改次数加1
modCount++;
//判断是否删除的是最后一个元素，
int numMoved = size - index - 1;
if (numMoved > 0)
//如果不是将删除位置后的元素向左移numMoved个位置
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将列表最后的元素置为null，等待垃圾收集器收集
elementData[--size] = null; // clear to let GC do its work
}
removeAll(Collection<?> c)
/**
从此列表中删除包含在指定集合中的所有元素。
参数：
c – 包含要从此列表中删除的元素的集合
返回：
如果此列表因调用而更改，则为true
抛出：
ClassCastException – 如果此列表的元素的类与指定的集合不兼容（可选）
NullPointerException – 如果此列表包含空元素并且指定的集合不允许空元素（可选），或者指定的集合为空
也可以看看：
Collection.contains(Object)
*/
public boolean removeAll(Collection<?> c) {
//进行判断，如果c为null抛出异常
Objects.requireNonNull(c);
return batchRemove(c, false);
}
// 接下来我们看batchRemove方法，以及它内部调用的方法。
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
//遍历数组，并检查这个集合是否包含对应的值，
//移动要保留的值到数组前面，w最后值为要保留的元素的数量,
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// 确保异常抛出前的部分可以完成期望的操作，而被遍历的部分会被接到后面
//r不等于size表示可能出错了
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
//如果w等于size，表示全部元素都保留了，所以也就没有删除操作发生，所以会返回false；反之，返回true，并更改数组
//而w不等于size的时候，即使try块抛出异常，也能正确处理异常抛出前的操作，因为w始终为要保留的前段部分的长度，数组也不会因此乱序
if (w != size) {
// clear to let GC do its work
// 下标大于等于w的元素都是需要删除的，因为上面try块中将需要保留的元素都移到的数组前段，也就是下标小于w的那些元素被保留了
for (int i = w; i < size; i++)
elementData[i] = null;
// 记录数组修改次数，
modCount += size - w;
// 设置数组最新元素个数
size = w;
// 返回删除成功
modified = true;
}
}
return modified;
}
clear()
public void clear() {
//将集合修改次数加1
modCount++;
//循环将列表中的所有元素置为null，等待垃圾收集器收集
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
//将列表长度设为0
size = 0;
}
查找元素
ArrayList提供了get(int index)用读取ArrayList中的元素。由于ArrayList是动态数组，所以我们完全可以根据下标来获取ArrayList中的元素，而且速度还比较快。
public E get(int index) {
//判断删除位置是否正确，如果大于列表长度会抛出异常
rangeCheck(index);
//直接返回列表中下标等于index的元素
return elementData(index);
}
判断元素是否存在列表中
ArrayList提供了contains(Object o)用于判断元素是否存在于列表中。
注意：contains方法会遍历ArrayList。
public boolean contains(Object o) {
//调用indexOf方法判断需要查找的元素在列表中的下标是否大于等于0，小于0则不存在
return indexOf(o) >= 0;
}
// 查找元素下标，和remove(Object o) 类似
public int indexOf(Object o) {
//因为ArrayList允许存在null，所以需要进行null判断
if (o == null) {
//遍历列表，如果列表存在null值的元素，直接返回其下标位置
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
//遍历列表，使用equals判断是否有相等的元素，有的话直接返回其下标位置
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
//列表中不能存在传进来的元素，返回-1
return -1;
}
最小化ArrayList的实际存储量
ArrayList提供了trimToSize()方法用于将底层数组的容量调整为当前列表保存的实际元素的大小
public void trimToSize() {
//将集合修改次数加1
modCount++;
//如果当前ArrayList的实际长度小于内部维护的数组的长度，将内部数组超过size后的空余的空间（包括null值）去除，调用Arrays.cppyof方法拷贝elementData，长度为size
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
截取ArrayList部分内容
ArrayList提供了subList(int fromIndex, int toIndex)方法来实现部分数据的截取。
可以从源码中看到其实是创建了一个SubList的内部对象，可以理解为是返回当前ArrayList的部分视图，其实指向的存放数据的还是一个地方。如果修改了subList返回的内容的话，原来的内容也会被修改。
因为sublist的get和set方法什么的 都是直接改的引用。
public List<E> subList(int fromIndex, int toIndex) {
//检查需要截取的下标位置是否正确
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
static void subListRangeCheck(int fromIndex, int toIndex, int size) {
if (fromIndex < 0)
throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
if (toIndex > size)
throw new IndexOutOfBoundsException("toIndex = " + toIndex);
if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex + ")");
}
// 是ArrayList的内部类
SubList(AbstractList<E> parent,
int offset, int fromIndex, int toIndex) {
this.parent = parent;
this.parentOffset = fromIndex;
this.offset = offset + fromIndex;
this.size = toIndex - fromIndex;
this.modCount = ArrayList.this.modCount;
}
小结
ArrayList自己实现了序列化和反序列化，因为它实现了writeObject和readObject方法。
ArrayList基于数组实现，会自动扩容。
添加元素时会自己判断是否需要扩容，最好指定一个大概的大小，防止后面多次扩容带来的内存消耗；删除元素时不会减少容量，删除元素时，将删除掉的位置元素置为null，下次gc就会自动回收这些元素所占的空间。
ArrayList是线程不安全的。
扫一扫
4800
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
