Java集合之ArrayList源码剖析(jdk1.8)
目录
1、简介
ArrayList是一种以数组实现的List，与数组相比，它具有动态扩展的能力，因此也可称之为动态数组。
查询快，增删慢，线程不安全。
继承图谱如下：
ArrayList实现了List, RandomAccess, Cloneable, java.io.Serializable等接口。
ArrayList实现了List，提供了基础的添加、删除、遍历等操作。
ArrayList实现了RandomAccess，提供了随机访问的能力。
ArrayList实现了Cloneable，可以被克隆。
ArrayList实现了Serializable，可以被序列化。
2、源码分析
1、属性
//用于序列化的id
private static final long serialVersionUID = 8683452581122892189L;
//默认构造方法的容量
private static final int DEFAULT_CAPACITY = 10;
//空数组，构造方法中参数为0时使用--->new ArrayList(0)
private static final Object[] EMPTY_ELEMENTDATA = {};
//空数组，默认构造方法使用--->new ArrayList()
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//临时存放元素的数组，使用transient修饰，不会被序列化
transient Object[] elementData;
//元素实际个数
private int size;
//数组能分配的最大内存，超出会OutOfMemoryError
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
2、构造方法
ArrayList有三个构造方法。
//构造方法一，传入容量
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() {
//当添加第一个元素时，扩容到默认大小10
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//构造方法三，传入一个集合，将其转化为ArrayList
public ArrayList(Collection<? extends E> c) {
//集合转数组
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// 检查c.toArray()返回的是不是Object[]类型，如果不是，重新拷贝成Object[].class类型
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 如果c的空集合，则初始化为空数组EMPTY_ELEMENTDATA
this.elementData = EMPTY_ELEMENTDATA;
}
}
3、简单方法
这部分方法有的是从高层继承下来的，有的是对高层方法的实现，较为简单，部分如下：
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
4、核心方法
这部分方法有些是对抽象List的实现，也有部分独属于ArrayList.
add(E e)方法
在ArrayList后面添加一个元素
public boolean add(E e) {
// 检查是否需要扩容
ensureCapacityInternal(size + 1);
// 把元素插入到最后一位
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 如果是空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，就初始化为默认大小10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
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;
// 如果新容量已经超过最大容量了，则使用最大容量
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 以新容量拷贝出来一个新数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
add(int index, E element)方法
添加元素到指定位置，平均时间复杂度为O(n)。
public void add(int index, E element) {
//检查是否越界
rangeCheckForAdd(index);
//检查是否需要扩容
ensureCapacityInternal(size + 1);
//将index及其后的元素向后移动一位，空出index的位置
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//空出的位置存放加入的元素
elementData[index] = element;
//数量加一
size++;
}
addAll(Collection<? extends E> c)方法
向ArrayList中加入集合，求并集
public boolean addAll(Collection<? extends E> c) {
//集合转为数组
Object[] a = c.toArray();
int numNew = a.length;
//检查扩容
ensureCapacityInternal(size + numNew);
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
addAll(int index, Collection<? extends E> c)
从指定位置加入集合。
public boolean addAll(int index, Collection<? extends E> c) {
//检查越界
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew);
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 != 0;
}
get(int index)方法
通过索引获取元素，复杂度为o(1)
public E get(int index) {
// 检查是否越界
rangeCheck(index);
// 返回数组index位置的元素
return elementData(index);
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
E elementData(int index) {
return (E) elementData[index];
}
remove(int index)方法
通过索引删除元素，复杂度为o(1)
public E remove(int index) {
// 检查是否越界
rangeCheck(index);
modCount++;
// 获取index位置的元素
E oldValue = elementData(index);
// 如果index不是最后一位，则将index之后的元素往前挪一位
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
// 将最后一个元素删除，帮助GC
elementData[--size] = null; // clear to let GC do its work
// 返回旧值
return oldValue;
}
remove(Object o)方法
删除指定元素值的元素，时间复杂度为O(n)。
public boolean remove(Object o) {
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;
}
private void fastRemove(int index) {
modCount++;
// 如果index不是最后一位，则将index之后的元素往前挪一位
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
// 将最后一个元素删除，帮助GC
elementData[--size] = null; // clear to let GC do its work
}
removeAll(Collection<?> c)方法
批量删除，也可以单方向求差集，复杂度o(n).
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
//删除所有在集合c中的元素
return batchRemove(c, false);
}
//批量删除，false代表在集合中的元素统统删除
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
retainAll(Collection<?> c)方法
求交集，复杂度o(n)
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
//此处为true，表明删除所有不在c中的元素
return batchRemove(c, true);
}
set(int index, E element) 方法
更新元素，复杂度o(1)
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
迭代器方法
ArrayList中的迭代器有两种。
public Iterator<E> iterator() {
return new Itr();
}
public ListIterator<E> listIterator() {
return new ListItr(0);
}
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
//迭代器
private class Itr implements Iterator<E> {
//可以向后遍历
}
//list迭代器
private class ListItr extends Itr implements ListIterator<E> {
//既可以向前也可以向后遍历
}
3、总结
（1）ArrayList内部使用数组存储元素，当数组长度不够时进行扩容，每次加一半的空间，ArrayList不会进行缩容；
（2）ArrayList支持随机访问，通过索引访问元素极快，时间复杂度为O(1)；
（3）ArrayList支持求并集，调用addAll(Collection<? extends E> c)方法即可；
（4）ArrayList支持求交集，调用retainAll(Collection<? extends E> c)方法即可；
（5）ArrayList支持求单向差集，调用removeAll(Collection<? extends E> c)方法即可；
（6）ArrayList有两种迭代器，支持向前向后遍历。
（7）ArrayList底层基于数组，所以除了迭代器，也可以使用循环遍历。
（8）ArrayList查询快，增删慢，线程不安全。