目录
前言
ArrayList是java编程中最常用的工具类之一,它解决了普通数组无法自动扩容的问题,是一个非常简单而又强大的工具,本篇博文将带你揭开ArrayList1.8神秘的面纱。
概要
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
ArrayList继承了AbstractList抽象类,实现了List、RandomAccess、Cloneable、Serializable接口;List接口规定了ArrayList的操作规范,RandomAccess是一个标志接口,意味着ArrayList支持快速随机访问,Cloneable接口用于克隆,Serializable接口则用来支持对象的序列化与反序列化。
ArrayList的数据结构不像HashMap那么复杂,它的存储由数组提供支持。因为数组是可以为空的,所以ArrayList可以存储多个null对象。
属性
// 默认初始容量
private static final int DEFAULT_CAPACITY = 10;
// 当指定数组的容量为0的时候使用这个变量赋值,空对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};
// 默认实例化的时候使用此变量赋值,空对象数组
// 用来区别EMPTY_ELEMENTDATA,后面将会详细解释
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 用来存储数据的数组,非私有以简化嵌套类的访问
// transient关键字表明此成员不参与对象序列化
transient Object[] elementData;
// 已存储元素的个数
private int size;
// 由于VM的限制,一般容量不要超过MAX_ARRAY_SIZE,但最大值可以是Integer.MAX_VALUE
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
构造方法
// 单参构造
public ArrayList(int initialCapacity) {
// 未限制initialCapacity的大小,所以最大容量为Integer.MAX_VALUE
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
// 容量为0,将第一个空数组赋值给它
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
// 构造一个初始容量为10的空列表。
public ArrayList() {
// 默认情况下,赋值第二个空数组,表示容量为默认初始容量
// 这也就是为什么给了两个空数组对象,就为了将两种情况区别开
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 用另一个集合来初始化本对象
public ArrayList(Collection<? extends E> c) {
// 得到缓存数组,赋值给成员elementData
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray可能(不正确地)不返回Object[]
// 当泛型是String时,返回的是String[]
if (elementData.getClass() != Object[].class)
// 此方法将详细讲解
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 用空数组替换,容量为0
this.elementData = EMPTY_ELEMENTDATA;
}
}
Arrays.copyOf()
// original: 原数组,newLength: 复制长度,newType: 返回数组的类型
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
// 如果是Object[].class,则new Object[newLength]
// 如果不是,则Array.newInstance(newType.getComponentType(), newLength);
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
// newType.getComponentType()可以得到数组类型
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
// 复制的长度不能超过原数组的最大值,否则可能会出现下标越界的问题
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
System.arraycopy() 是一个本地方法,这个方法将src作为原数组,从srcPos起开始复制,复制到目标数组dest中,dest数组从destPos开始复制,一共复制length个;而在方法的参数中,src和dest并不是数组类型,因此可以猜测,此方法应该是通过物理内存的起始地址和偏移量来完成复制的。
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
核心方法
此模块将列举一些常用的方法,也会对关联的方法进行讲解。
get(int index)
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
public E get(int index) {
// 检查数组下标的范围,防止下标越界
rangeCheck(index);
return elementData(index);
}
rangeCheck(int index)
// 封装的下标越界检查,被get()、remove()等方法使用
private void rangeCheck(int index) {
// 并没有检查下标是否小于0,因为在elementData[index]操作中,
// jvm会帮我们检查越界问题
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
// 构造异常的具体信息
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
set(int index, E element)
public E set(int index, E element) {
// 检查下标
rangeCheck(index);
// 替换旧值
E oldValue = elementData(index);
elementData[index] = element;
// oldValue 可能为 null
return oldValue;
}
add(E e)
// 在数组有效元素末尾插入
public boolean add(E e) {
// 添加前判断容量够不够,不够扩容;最重要的是增量modCount
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
// 指定下标插入元素
public void add(int index, E element) {
// 检查下标的合法性
rangeCheckForAdd(index);
// 添加前判断容量够不够,不够扩容;最重要的是增量modCount
ensureCapacityInternal(size + 1);
// 数组元素后移,留下该下标元素的位置,为插入element做准备
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 插入元素
elementData[index] = element;
size++;
}
rangeCheckForAdd(int index)
// 由add()和addAll()使用的版本
// add()和addAll()中调用了native的System.copyOf()方法
// 所以需要判断 index < 0,与rangeCheck(int index)不同
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
ensureCapacityInternal(int minCapacity)
这个方法的作用是保证数组有充足的容量来容纳新的元素
// 本方法调用了两个方法,下面将依次讲解
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 无参构造规定容量不能小于默认容量10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
// 修改数+1,调用此方法的方法不用再写这一步
modCount++;
// 如果需要的最小容量大于数组长度,则扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
grow(int minCapacity) - 扩容
//增加容量,以确保至少可以容纳由minCapacity指定的元素数量
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
// oldCapacity >> 1 = oldCapacity * 1/2
// oldCapacity + oldCapacity / 2 = oldCapacity * 3/2
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 计算的新容量小于要求的最小容量(minCapacity),则选择最小容量
// 如果大于,使用计算的容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果newCapacity大于MAX_ARRAY_SIZE,就尝试用最小容量
// 若minCapacity也超过了MAX_ARRAY_SIZE,则用Integer.MAX_VALUE
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity通常接近于size,所以复制效率较高
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // 溢出
throw new OutOfMemoryError();
// 最大值可以是 Integer.MAX_VALUE
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
addAll(Collection<? extends E> c)
// 所以元素尾加到elementData中
public boolean addAll(Collection<? extends E> c) {
// 将List变为Object数组
Object[] a = c.toArray();
int numNew = a.length;
// 确保容量足够
ensureCapacityInternal(size + numNew); // 增量modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
// 所以元素插入到elementData数组的指定index中
public boolean addAll(int index, Collection<? extends E> c) {
// 检查下标合法性
rangeCheckForAdd(index);
// 将List变为Object数组
Object[] a = c.toArray();
int numNew = a.length;
// 确保容量足够
ensureCapacityInternal(size + numNew); // 增量modCount
int numMoved = size - index;
if (numMoved > 0)
// 先将位置空出来,为插入作准备
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
// 这里省去了for循环的赋值
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
toArray()
// elementData的浅克隆(测试得出)
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
//public static <T> T[] copyOf(T[] original, int newLength) {
// return (T[]) copyOf(original, newLength, original.getClass());
//}
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
// 数据可能会丢失,根据用户给的数组确定,a.length
if (a.length < size)
// 返回的数组的长度为size,但a的长度不够保存
// 所以会有部分数据丢失,且a数组被填满
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
// 返回的数组的长度为a.length
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
// 若a.length = size,不会执行这一步
// 数组下标从 0 到 size - 1,共size个
a[size] = null;
return a;
}
remove(Object o)
// 删除指定下标元素
public E remove(int index) {
rangeCheck(index);
// 修改数+1
modCount++;
// 取得要删除的数据
E oldValue = elementData(index);
// 需要移动的个数
int numMoved = size - index - 1;
if (numMoved > 0)
// 这里直接就覆盖了该元素,不用再进行删除的那一步
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 清除,让GC做它的工作
elementData[--size] = null;
return oldValue;
}
// 删除第一个匹配的元素(从头遍历),没有则返回false
public boolean remove(Object o) {
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++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
// 工具内部的删除,一定是对象匹配才能删,所以不用rangeCheck(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;
}
// 暴力删除,让gc回收
public void clear() {
modCount++;
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
iterator()
// 按适当的顺序对列表中的元素返回一个迭代器。
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
// 下一个要返回的元素的索引
int cursor;
// 最后一个返回元素的索引(上一个返回的元素);如没有返回-1
int lastRet = -1;
// 确定修改数,保证线程安全
int expectedModCount = modCount;
Itr() {}
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
// 检查修改数是否相同,判断线程的安全性
checkForComodification();
// 第一次为0,因为int成员初始值为0
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
// 上面已经判断i < size成立,而size <= elementData.length
// 所以下面条件成立则说明进行了容量收缩,线程不安全
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
// 保证修改数同步,不会造成线程不安全
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
// 如果下标越界了,那么肯定是对elementData进行了删除等操作
throw new ConcurrentModificationException();
}
}
// 显式的forEach调用,遍历剩下的所有元素
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
// 判断consumer 是否为 null
Objects.requireNonNull(consumer);
// final关键字修饰,不可更改
final int size = ArrayList.this.size;
// 接着之前的继续遍历
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
// 遍历后面的元素,并判断修改数是否相同,如果不同立即停止循环
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// 确定下一个返回值的下标和上一个返回值的下标
cursor = i;
lastRet = i - 1;
// 检查线程同步
checkForComodification();
}
// 通过修改数的对比,判断是否对原数组进行了修改
// 在产生Itr对象时,就确定了expectedModCount的大小
// 如果在外部类进行了修改操作,就会被认为是线程不安全的行为
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
总结
到此,ArrayList1.8的基本属性、构造方法和它的核心方法已经基本讲解完毕了,希望读者能从中有所收获。