ArrayList是list的一个重要的实现,是经常会在代码中见到的一个几个,值得我们仔细的看一看。
ArrayList继承AbstractList类,实现List、RandomAccess,、Cloneable、java.io.Serializable等接口,AbstractList、List、RandomAccess在之前的博文中都有说道,Cloneable、Serializable接口跟RandomAccess类似,接口没有需要实现的方法,是一种功能标志接口,Cloneable标志支持clone操作,Serializable标志支持序列化功能。
ArrayList是大小可变的数组实现,实现了list中的所有可选的操作,允许所有的元素当然也包括null元素,除去list接口中定义的各种操作,ArrayList内部还提供了巧妙改变数组大小的方法,ArrayList大致上跟Vector类似,或者说是非同步的Vector。
ArrayList各种操作中,size、isEmpty、get、set、iterator、listIterator操作的时间复杂度较低,因为ArrayList支持随机访问,所以这类操作的时间复杂度为O(1);add方法的时间复杂度较高为O(n);其他方法的时间复杂度都是线性的。
ArrayList并不是现行安全的,也因此iterators是fail-fast的:iterator产生之后如果list发生变化(add、remove操作),list就会在最快的时间内抛出ConcurrentModificationException(不懂fail-fast可以点这里简单了解下),所以呢若在多线程环境下并发访问一个ArrayList实例,并且至少一个线程对其作了结构型修改,那么必须在外部做同步。
下面来细细地看一看ArrayList内部的一些东西:
变量
//序列化需要的序列码
private static final long serialVersionUID = 8683452581122892189L;
//默认的大小,使用默认构造器初始化大小为10的数组
private static final int DEFAULT_CAPACITY = 10;
//默认空数组,初始化大小为0时使用
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认空数组,初始化大小为默认10时使用,当添加第一个元素的时候,这个数组的大小便会被初始化为默认大小,
//便能与EMPTY_ELEMENTDATA区分开
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//存放元素的数组,transient修饰表示表示这个变量不属于序列化的一部分
transient Object[] elementData;
//ArrayList的大小,与elementData的大小一致
private int size;
//最大的数组大小,
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
大部分都好理解,就是这个elementData在初看的时候会有一点疑惑,ArrayList是支持序列化的,但是存放元素的数组又不支持序列化,岂不是ArrayList经历序列化和反序列之后元素全部都挂掉了?不知道各位在刚看的时候会不会像笔者一样有这个疑惑,这个先放着,我们把相关的方法解释完自然会明白。
其他的,为什么最大的数组大小比正数最大值少8之前有说过,可以翻看之前的博文AbstractCollection
构造器
//无参构造器,存放元素的数组为DEFAULTCAPACITY_EMPTY_ELEMENTDATA
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//接收一个大于等于0的int型值作为数组初始大小,如果初始值为0,存放元素的数组为EMPTY_ELEMENTDATA
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);
}
}
//接收一个集合类型的参数,将集合中的元素复制进ArrayList存放元素的数组中
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;
}
}
方法
trimToSize()方法
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
}
}
将集合的容量为集合当前的大小,最小化集合的操作
ensureCapacity(int minCapacity)方法
public void ensureCapacity(int minCapacity) {
//获取当前元素存放数组大小
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0 : DEFAULT_CAPACITY;
//当前数组大小小于期望大小时进行扩容
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
private void ensureExplicitCapacity(int minCapacity) {
//增加改变次数
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
//新集合的默认扩容大小是集合大小的1.5倍
int oldCapacity = elementData.length;
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);
}
//如果默认扩容大小大于大于正数最大值,会根据期望容量的大小设定新的集合大小
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
从整个集合扩容的过程中能得到的信息:
1、默认构造器创建的arrayList初始的容量为0,从添加第一个元素开始初始容量扩展为10
2、arrayList的最大容量为int型的最大值
既然看了扩容的方法,那么我们就把跟扩容相关的方法整个看完:
add(E e)、add(int index, E element)
addAll(Collection <? extends E> c)、addAll(int index, Collection<? extends E> c)
public boolean add(E e) {
//扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//默认添加在集合的最末尾
elementData[size++] = e;
return true;
}
public void add(int index, E element) {
//检验index值是否合理
rangeCheckForAdd(index);
//扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//复制并后移
System.arraycopy(elementData, index, elementData, index + 1,size - index);
elementData[index] = element;
size++;
}
//两个addall方法的套路跟add(int index, E element)的方式差不多,只是复制赋值的时候参数稍微有些区别
//这里笔者有一个疑惑,如果参数集合元素个数为0,addall方法其实没有让集合发生任何改变,为什么不直接返回?
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
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;
}
//确定期望扩容的大小,然后调上面说的扩容方法实现扩容
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
return Math.max(DEFAULT_CAPACITY, minCapacity);
return minCapacity;
}
contains(Object o)、indexOf(Object o)、lastIndexOf(Object o)
//用获取的下标大小来实现
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
//返回元素的下标,否则返回-1
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
//作用与indexOf相同,只不过顺序相反
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
clone()方法
public Object clone() {
try {
//返回跟之前一样的ArrayList,其他一样,但刷新修改次数
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
//未实现cloneable接口会抛出此异常
throw new InternalError(e);
}
}
toArray()方法
//相比于AbstractCollection的实现更加简洁,在于ArrayList中有用于存放元素的数组
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
public <T> T[] toArray(T[] a) {
//指定集合的容量小的话会新产生一个集合再进行复制,否则直接赋值且复制完原ArrayList中的元素之后,
//赋值一个null,其他的元素还跟指定集合的元素一样,这个有一些诡异,不知出于何种目的(仅仅是分隔线么)?
if (a.length < size)
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
get(int index)、set(int index, E element)
比较常用的两个方法,都会先进行参数的检查然后进行后续的操作。
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
remove(int index)、remove(Object o)方法
//先改变modcount值
//然后根据index删除元素:实质上是index的位置的元素被后续元素覆盖,最后一个元素赋值为null
//感觉也可以调用fastRemove方法
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);
elementData[--size] = null;
return oldValue;
}
//直接删除元素会有一个查找的过程,后续跟remove(int index)方法一致
//如果ArrayList中有相同元素,只删除位置靠前的那一个
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位起,后续的元素向前一位复制
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
}
//跟上面的方法基本是一个套路,只是参数的整理多一点
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved);
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++)
elementData[i] = null;
size = newSize;
}
clear()方法
public void clear() {
modCount++;
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
清空集合的方法:先改变modcount值,而后循环把每一个元素变为null
removeAll(Collection<?> c)、retainAll(Collection<?> c)
//删除出现在指定集合中的所有元素
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
//只保留出现在指定集合中的元素
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
//逐个进行筛选,r表示进行到的位置,w表示符合要求的个数
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
//容灾性代码,即使contains方法抛出异常,完成多少就保存多少
if (r != size) {
System.arraycopy(elementData, r, elementData, w, size - r);
w += size - r;
}
//成功删除多少个,就赋值几个null
if (w != size) {
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
readObject(java.io.ObjectInputStream s)、writeObject(java.io.ObjectOutputStream s)方法
这两个方法就是文章开始时候说的那个疑问:elementData用transient关键字修饰的原因
ArrayList内部使用数组来实现元素的存储,而在序列化的时候我们并不希望去序列化那些无用的元素,仅仅只序列化和反序列化我们需要的size()个元素,所以才使用transient关键字,让数组本身不能被序列化,而使用指定的方法对数组持有的对象进行序列化。
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
//读入size和其他隐藏的东西
s.defaultReadObject();
//读入容量
s.readInt();
if (size > 0) {
int capacity = calculateCapacity(elementData, size);
SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
ensureCapacityInternal(size);
Object[] a = elementData;
for (int i=0; i<size; i++) {
//读取数组中的每一个元素
a[i] = s.readObject();
}
}
}
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
int expectedModCount = modCount;
//写入元素个数和其他隐藏的东西
s.defaultWriteObject();
//写入容量值
s.writeInt(size);
for (int i=0; i<size; i++) {
//写入每一个数组元素
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
这就是ArrayList前800行的源码,之后还有700行的代码主要是迭代器、子集合、可分割集合的相关实现和其他一些小的方法,写在一起貌似有点太多了,就分开写好了。