Java 源码分析之ArrayList

本文基于jdk1.7源码分析

ArrayList 简介

ArrayList 底层是基于数组实现的,是一个动态数组,当存储空间不足时,会自动扩容，ArrayList 不是线程安全的,如果要在多线程环境下使用,可以使用Collections.synchronizedList(List list)获取一个线程安全的List对象,或使用java.util.concurrent.CopyOnWriteArrayList类生成一个线程安全的List.

ArrayList 结构

RandomAccess, Cloneable, Serializable 这三个接口都是标记接口,没有定义方法和参数。

RandomAccess 接口,表示该类支持随机访问,即通过下标访问。

Cloneable 接口,表示该类能被克隆。

Serializable 接口,表示该类支持序列化。

ArrayList 源码之构造方法

不带参数的构造方法,该方法默认构建一个初始化容量为10的列表。

public ArrayList() {
this(10);
}

2.该构造方法可指定列表的初始化容量,在知道数据量的情况下,可适当调整初始化容量,避免多次扩容,提高性能。

public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
// 创建指定容量的Object数组
this.elementData = new Object[initialCapacity];
}

3.创建一个包含collection的ArrayList

public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
size = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}

ArrayList 之增删查

ArrayList 之添加数据

// 添加元素
public boolean add(E e) {
ensureCapacity(size + 1);  // 检查容量,如果容量不足,对数组进行扩容
elementData[size++] = e;   // 将数据添加到数组中
return true;
}
// 添加元素到指定位置
public void add(int index, E element) {
if (index > size || index < 0)  // 判断指定的下标是否合理
throw new IndexOutOfBoundsException(
"Index: "+index+", Size: "+size);

ensureCapacity(size+1);  // 检查容量
System.arraycopy(elementData, index, elementData, index + 1,
size - index);// 数组复制,将index位置空出来,index的数据后移
elementData[index] = element; // 将元素存入index位置
size++;// List 大小自增
}

// 添加一个集合的数据到List中
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();// 获取数据数组
int numNew = a.length; // 得到数组长度
ensureCapacity(size + numNew);  // 检查添加这些数据,容量是否足够,不够进行扩容
System.arraycopy(a, 0, elementData, size, numNew);// 复制集合中的数据到List
size += numNew;// List大小增加数组长度
return numNew != 0;
}

//添加一个集合到指定下标
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0) //判断下标是否合法
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);

Object[] a = c.toArray(); // 获取集合数据数组
int numNew = a.length; // 获取数组长度
ensureCapacity(size + numNew);  // 检查添加这些数据,容量是否足够,不够进行扩容

int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);// 移动List中的数据,空出位置给添加进来的集合,

System.arraycopy(a, 0, elementData, index, numNew); // 将集合中的数据复制到List
size += numNew; // List大小增加数组长度
return numNew != 0;
}

// 检查容量
public void ensureCapacity(int minCapacity) {
modCount++;// 列表结构修改的次数
int oldCapacity = elementData.length;// List 容量长度
if (minCapacity > oldCapacity) { // 判断新增后的长度是否大于容量长度,如果大于说明List的容量不够了,需要扩容
Object oldData[] = elementData; // 得到老的数据数组
int newCapacity = (oldCapacity * 3)/2 + 1; //计算 新的容量=(原始容量x3)/2 + 1
if (newCapacity < minCapacity) // 如果计算出来的容量,还是小了,则使用新增数据后的长度作为容量
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);// 复制List的数据到指定容量的数组中,返回新的数组
}
}

2.ArrayList 之查询数据

// 获取指定下标的数据
public E get(int index) {
rangeCheck(index);  // 判断指定下标是否合理

return elementData(index);// 返回指定下标中的数据
}
// 检查下标是否合理
private void rangeCheck(int index) {
if (index >= size) // 如果获取的下标超过了List集合的大小,就跑下标越界异常
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
// 查找元素下标
public int indexOf(Object o) {
if (o == null) { // 如果元素为空
for (int i = 0; i < size; i++)// 遍历List
if (elementData[i]==null)
return i;// 返回下标
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1; //没有找到返回-1
}

// 从后往前查找元素下标
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; // 没有找到该元素,返回-1
}

3.ArrayList 之删除数据

// 根据下标删除元素
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);// 移动数组中的数据,index后的数据往前移动
elementData[--size] = null; //将末尾的数据置为null

return oldValue;// 返回删除的数据
}

// 根据元素删除
public boolean remove(Object o) {
if (o == null) { // 判断需要删除的数据是否为null
for (int index = 0; index < size; index++)// 遍历集合
if (elementData[index] == null) {// 判断数据为null
fastRemove(index);// 根据下标删除
return true;// 返回删除结果
}
} else {
for (int index = 0; index < size; index++)// 遍历集合
if (o.equals(elementData[index])) {// 判断数据是否相等
fastRemove(index);// 根据下标删除该数据
return true;
}
}
return false;// 没找到该元素,返回false
}
// 根据下标快速删除,不返回删除的元素
private void fastRemove(int index) {
modCount++;// 操作数自增
int numMoved = size - index - 1;// 需要移动的数据个数
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);// 移动数组中的数据,index后的数据往前移动
elementData[--size] = null; //将末尾的数据置为null
}

// 清空集合
public void clear() {
modCount++;// 操作数自增

// 遍历集合
for (int i = 0; i < size; i++)
elementData[i] = null;// 将所有数据置为null

size = 0;// 将集合大小置为0
}

// 删除指定范围的数据,但该方法却是protected
protected void removeRange(int fromIndex, int toIndex) {
modCount++;// 操作数自增
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);//移动数组中的数据,toIndex后的数据往前移动
// Let gc do its work
int newSize = size - (toIndex-fromIndex);// 计算删除数据后的size大小
while (size != newSize)// 删除多少个元素,就从后往前置空多少元素
elementData[--size] = null;
}

// 删除两个集合的差集
public boolean removeAll(Collection<?> c) {
return batchRemove(c, false);// false表示不包含
}

//删除两个集合的交集
public boolean retainAll(Collection<?> c) {
return batchRemove(c, true);// true表示包含
}

// 移除数据
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) {
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}

总结

ArrayList底层是使用数组存储数据,基于下标访问,所有查询快。
在已知数据数量的情况下,可以在创建ArrayList对象的时候指定初始化容量,避免多次扩容，提高效率。
ArrayList删除数据时会去复制数组，移动数据，所以效率较低.