一、简介
ArrayList结构
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
1、AbstractList,实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
2、ArrayList 继承了AbstractList,实现了List。它是一个数组队列,提供了相关的添加、删除、修改、遍历等功能。
3、ArrayList 实现了RandmoAccess接口,即提供了随机访问功能。RandmoAccess是java中用来被List实现,为List提供快速访问功能的。在ArrayList中,我们即可以通过元素的序号快速获取元素对象;这就是快速随机访问。
4、ArrayList 实现了Cloneable接口,即覆盖了函数clone(),能被克隆。
5、ArrayList 实现java.io.Serializable接口,这意味着ArrayList支持序列化,能通过序列化去传输。
注意
和Vector不同,ArrayList中的操作不是线程安全的!所以,建议在单线程中才使用ArrayList,而在多线程中可以选择Vector或者CopyOnWriteArrayList,或者使用Collections工具类的synchronizedList方法将其包装
二 、源码分析
1、ArrayList属性
//序列号
private static final long serialVersionUID = 8683452581122892189L;
//默认初始容量
private static final int DEFAULT_CAPACITY = 10;
//一个空数组,当用户指定ArrayList容量为0时,返回该数组
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 一个空数组实例
* - 当用户没有指定 ArrayList 的容量时(即调用无参构造函数),返回的是该数组==>刚创建一个 ArrayList 时,其内数据量为 0。
* - 当用户第一次添加元素时,该数组将会扩容,变成默认容量为 10(DEFAULT_CAPACITY) 的一个数组===>通过 ensureCapacityInternal() 实现
* 它与 EMPTY_ELEMENTDATA 的区别就是:该数组是默认返回的,而后者是在用户指定容量为 0 时返回
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//当前数据对象存放地方,当前对象不参与序列化
//这个关键字最主要的作用就是当序列化时,被transient修饰的内容将不会被序列 化
transient Object[] elementData; // non-private to simplify nested class access
//ArrayList实际存储的数据数量
private int size;
//继承于AbstractList
//集合数组修改次数的标识
protected transient int modCount = 0;
size和elementData.length是不相同的
- size:是指当前集合中存在的元素个数
- elementData.length:是指当前集合指定的容量大小
例如:
如果我们new ArrayList()时,ArrayList只是给我们默认的elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA,此时只是空数组,
只有第一次add时才默认数组的大小为DEFAULT_CAPACITY=10 ,此时elementData.length=10,而size=0
2、ArrayList构造函数
/**
* 创建一个初试容量的、空的ArrayList
* @param initialCapacity 初始容量
* @throws IllegalArgumentException 当初试容量值非法(小于0)时抛出
*/
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,此时其内数组缓冲区 elementData = {}, 长度为 0
* - 当元素第一次被加入时,扩容至默认容量 10
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 创建一个包含collection的ArrayList
* @param c 要放入 ArrayList 中的集合,其内元素将会全部添加到新建的 ArrayList 实例中
* @throws NullPointerException 当参数 c 为 null 时抛出异常
*/
public ArrayList(Collection<? extends E> c) {
//把集合传化成Object[]数组
elementData = c.toArray();
//转化后的数组长度赋给当前ArrayList的size,并判断是否为0
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
//c.toArray可能不会返回 Object[],可以查看 java 官方编号为 6260652 的 bug
if (elementData.getClass() != Object[].class)
// 若 c.toArray() 返回的数组类型不是 Object[],则利用 Arrays.copyOf(); 来构造一个大小为 size 的 Object[] 数组
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 替换空数组
this.elementData = EMPTY_ELEMENTDATA;
}
}
Arrays.copyOf方法
/*
复制指定的数组,截断或填充空字符,以便复制具有指定的长度
- original:要复制的数组
- newLength:要返回的数组的长度
*/
public static char[] copyOf(char[] original, int newLength) {
char[] copy = new char[newLength];
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
return copy;
}
//指定复制数组的范围
public static char[] copyOfRange(char[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
char[] copy = new char[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
/*
original - 要复制的数组
newLength - 要返回的副本的长度
newType - 要返回的副本的类型
*/
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
//根据class的类型来决定是new 还是反射去构造一个泛型数组
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
//利用native函数,批量赋值元素至新数组中。
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
System.arraycopy方法
/*
将指定源数组的数组,从指定位置,复制到指定数组的指定位置,要赋值的数组元素数量等于length。
- src:源数组
- srcPos:源数组中的起始位置
- dest:目标数组
- destPos:目标数组的起始位置
- length:要赋值的数组元素数量
*/
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
3、方法分析
1、add(E e)方法
快速掌握的方法:debug一遍
1.1 如果没有指定初始化容量,第一次调用add()方法,会初始化容量为10
如果一开始指定了初始化容量,假如为4,那么只有在添加第5个元素时,ensureExplicitCapacity方法里的if语句里的minCapacity-elementData.length > 0 才能成立,此时就会以原容量的1.5倍进行扩容。
1.2 如果超出数组容量,默认分配大小为原数组的1.5倍。如果分配的数组过大(超过Integer.MAX_VALUE - 8,一般都不会那么大),则调用hugeCapacity静态方法 ,如果minCapacity介于Integer.MAX_VALUE - 8到Integer.MAX_VALUE,则直接分配一个Integer.MAX_VALUE大小的数组,否则抛出OutOfMemoryError。
1、确保数组已使用长度(size)加1之后足够存下 下一个数据
2、修改次数modCount 标识自增1,如果当前数组已使用长度(size)加1后的大于当前的数组长度,则调用grow方法,增长数组,grow方法会将当前数组的长度变为原来容量的1.5倍。
3、确保新增的数据有地方存储之后,则将新元素添加到位于size的位置上。
4、返回添加成功布尔值。
/**
*增加指定的元素到ArrayList的最后位置
* @param e 要添加的元素
* @return
*/
public boolean add(E e) {
// 确定ArrayList的容量大小---严谨
// 注意:size + 1,保证资源空间不被浪费,
// ☆☆☆按当前情况,保证要存多少个元素,就只分配多少空间资源
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
/**
* 私有方法:明确 ArrayList 的容量,提供给本类使用的方法
* - 用于内部优化,保证空间资源不被浪费:尤其在 add() 方法添加时起效
* @param minCapacity 指定的最小容量
*/
private void ensureCapacityInternal(int minCapacity) {
// 若 elementData == {},则取 minCapacity 为 默认容量和参数 minCapacity 之间的最大值
// 注:ensureCapacity() 是提供给用户使用的方法,在 ArrayList 的实现中并没有使用
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity= Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
/**
* 私有方法:明确 ArrayList 的容量
* - 用于内部优化,保证空间资源不被浪费:尤其在 add() 方法添加时起效
* @param minCapacity 指定的最小容量
*/
private void ensureExplicitCapacity(int minCapacity) {
// 将“修改统计数”+1,该变量主要是用来实现fail-fast机制的
modCount++;
// 防止溢出代码:确保指定的最小容量 > 数组缓冲区当前的长度
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* 数组缓冲区最大存储容量
* - 一些 VM 会在一个数组中存储某些数据--->为什么要减去 8 的原因
* - 尝试分配这个最大存储容量,可能会导致 OutOfMemoryError(当该值 > VM 的限制时)
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 私有方法:扩容,以确保 ArrayList 至少能存储 minCapacity 个元素
* - 扩容计算:newCapacity = oldCapacity + (oldCapacity >> 1); 扩充当前容量的1.5倍
* @param minCapacity 指定的最小容量
*/
private void grow(int minCapacity) {
// 防止溢出代码
int oldCapacity = elementData.length;
// 运算符 >> 是带符号右移. 如 oldCapacity = 10,则 newCapacity = 10 + (10 >> 1) = 10 + 5 = 15
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0) // 若 newCapacity 依旧小于 minCapacity
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) // 若 newCapacity 大于最大存储容量,则进行大容量分配
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
/**
* 私有方法:大容量分配,最大分配 Integer.MAX_VALUE
* @param minCapacity
*/
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
void add(int index, E element)
1、检查数组下标是否越界,越界抛出异常
2、确保数组已使用长度(size)加1之后足够存下 下一个数据
3、修改次数modCount 标识自增1,如果当前数组已使用长度(size)加1后的大于当前的数组长度,则调用grow方法,增长数组,grow方法会将当前数组的长度变为原来容量的1.5倍。
4、使用System.arraycopy把index后面的元素都往后移动一位,腾出index位置
5、将新的数据放到指定位置index上
public void add(int index, E element) {
//判断索引是否越界
rangeCheckForAdd(index);
//确保已使用数组长度size+1能够存下数据
ensureCapacityInternal(size + 1); // Increments modCount!!
//elementData:要复制的数组,index从哪里开始复制
//elementData:目标数组,index复制到的数组第几个开始,最后一个是复制长度
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
//检查下标是否越界
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
2、remove(int index)方法
1、判断索引是否越界
2、增加修改的次数
3、保存要删除的元素为oldValue
4、将指定位置index+1往后的元素都向前移动一位,覆盖需要删除的元素
5、将最后一个元素置空,GC
6、返回删除的元素
/**
* 移除指定位置的元素
* index 之后的所有元素依次左移一位
* @param index 指定位置
* @return 被移除的元素
* @throws IndexOutOfBoundsException
*/
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;
}
/**
* 检查数组是否在界线内
*/
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
remove(Object o)
/**
* 移除list中指定的第一个元素(符合条件索引最低的)
* 如果list中不包含这个元素,这个list不会改变
* 如果包含这个元素,index 之后的所有元素依次左移一位
* @param o 这个list中要被移除的元素
* @return
*/
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;
}
/**
* 快速删除第 index 个元素
* 和public E remove(int index)相比
* 私有方法,跳过检查,不返回被删除的值
* @param index 要删除的脚标
*/
private void fastRemove(int index) {
modCount++;//这个地方改变了modCount的值了
int numMoved = size - index - 1;//移动的个数
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; //将最后一个元素清除
}
3、iterator迭代器
迭代器统一了对容器的访问方式,能够将遍历序列的操作与序列底层的结构分离。
1、使用方法iterator()要求容器返回一个Iterator。Iterator将准备号返回序列的第一个元素
2、使用next()获得序列中的下一个元素
3、使用hasNext()检查序列是否还有元素
4、使用remove()将迭代器新近返回的元素删除
/**
* 以一种合适的排序返回一个iterator到元素的结尾
*/
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // 下一个元素返回的索引
int lastRet = -1; // 最后一个元素返回的索引 -1 if no such
int expectedModCount = modCount;
/**
* 是否有下一个元素
*/
public boolean hasNext() {
return cursor != size;
}
/**
* 返回list中的值
*/
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;//i当前元素的索引
if (i >= size)//第一次检查:角标是否越界越界
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)//第二次检查,list集合中数量是否发生变化
throw new ConcurrentModificationException();
cursor = i + 1; //cursor 下一个元素的索引
return (E) elementData[lastRet = i];//最后一个元素返回的索引
}
/**
* 移除集合中的元素
*/
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
//移除list中的元素
ArrayList.this.remove(lastRet);
//由于cursor比lastRet大1,所有这行代码是指指针往回移动一位
cursor = lastRet;
//将最后一个元素返回的索引重置为-1
lastRet = -1;
//重新设置了expectedModCount的值,避免了ConcurrentModificationException的产生
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
/**
* 检查modCount是否等于expectedModCount
* 在 迭代时list集合的元素数量发生变化时会造成这两个值不相等
*/
final void checkForComodification() {
//当expectedModCount和modCount不相等时,就抛出ConcurrentModificationException
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
并发修改异常
深入分析for-each和迭代器
1、foreach可以操作数组: 底层依然采用for循环+ 索引来获取数组元素.
2、foreach可以操作Iterable的实例:底层其实采用的Iterator(迭代器).
为什么会报ConcurrentModificationException异常?
1、Iterator 是工作在一个独立的线程中,并且拥有一个 mutex 锁。
2、 Iterator 被创建之后会建立一个指向原来对象的单链索引表,当原来的对象数量发生变化时,
这个索引表的内容不会同步改变,所以当索引指针往后移动的时候就找不到要迭代的对象。
3、所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
4、所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象,
5、Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。
在Collection接口中存在删除指定元素的方法:boolean remove(Object ele),该方法只能从集合中删除元素,不能把迭代器中指定的元素也删除。
如何解决并发修改异常呢?
不要使用集合对象的删除方法,使用Iterator中的remove方法,方法会从两个线程中同时移除被删除的元素,.保证了两个线程的同步.
ListItr,可以双向迭代
/**
* AbstractList.ListItr 的优化版本
* ListIterator 与普通的 Iterator 的区别:
* - 它可以进行双向移动,而普通的迭代器只能单向移动
* - 它可以添加元素(有 add() 方法),而后者不行
*/
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
}
/**
* 是否有前一个元素
*/
public boolean hasPrevious() {
return cursor != 0;
}
/**
* 获取下一个元素的索引
*/
public int nextIndex() {
return cursor;
}
/**
* 获取 cursor 前一个元素的索引
* - 是 cursor 前一个,而不是当前元素前一个的索引。
* - 若调用 next() 后马上调用该方法,则返回的是当前元素的索引。
* - 若调用 next() 后想获取当前元素前一个元素的索引,需要连续调用两次该方法。
*/
public int previousIndex() {
return cursor - 1;
}
/**
* 返回 cursor 前一元素
*/
@SuppressWarnings("unchecked")
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)//第一次检查:索引是否越界
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)//第二次检查
throw new ConcurrentModificationException();
cursor = i;//cursor回移
return (E) elementData[lastRet = i];//返回 cursor 前一元素
}
/**
* 将数组的最后一个元素,设置成元素e
*/
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
//将数组最后一个元素,设置成元素e
ArrayList.this.set(lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
/**
* 添加元素
*/
public void add(E e) {
checkForComodification();
try {
int i = cursor;//当前元素的索引后移一位
ArrayList.this.add(i, e);//在i位置上添加元素e
cursor = i + 1;//cursor后移一位
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
4 、其他部分方法
/**
* 将数组缓冲区大小调整到实际 ArrayList 存储元素的大小,即 elementData = Arrays.copyOf(elementData, size);
* - 该方法由用户手动调用,以减少空间资源浪费的目的 ce.
*/
public void trimToSize() {
// modCount 是 AbstractList 的属性值:protected transient int modCount = 0;
// [问] modCount 有什么用?
modCount++;
// 当实际大小 < 数组缓冲区大小时
// 如调用默认构造函数后,刚添加一个元素,此时 elementData.length = 10,而 size = 1
// 通过这一步,可以使得空间得到有效利用,而不会出现资源浪费的情况
if (size < elementData.length) {
// 注意这里:这里的执行顺序不是 (elementData = (size == 0) ) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
// 而是:elementData = ((size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size));
// 这里是运算符优先级的语法
// 调整数组缓冲区 elementData,变为实际存储大小 Arrays.copyOf(elementData, size)
//先判断size是否为0,如果为0:实际存储为EMPTY_ELEMENTDATA,如果有数据就是Arrays.copyOf(elementData, size)
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
/**
* 指定 ArrayList 的容量
* @param minCapacity 指定的最小容量
*/
public void ensureCapacity(int minCapacity) {
// 最小扩充容量,默认是 10
//这句就是:判断是不是空的ArrayList,如果是的最小扩充容量10,否则最小扩充量为0
//上面无参构造函数创建后,当元素第一次被加入时,扩容至默认容量 10,就是靠这句代码
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
? 0
: DEFAULT_CAPACITY;
// 若用户指定的最小容量 > 最小扩充容量,则以用户指定的为准,否则还是 10
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
/**
* 移除list中的所有元素,这个list表将在调用之后置空
* - 它会将数组缓冲区所以元素置为 null
* - 清空后,我们直接打印 list,却只会看见一个 [], 而不是 [null, null, ….] ==> toString() 和 迭代器进行了处理
*/
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
参考:https://www.cnblogs.com/gxl1995/p/7534171344218b3784f1beb90d621337.html(合并详细)
参考:https://blog.csdn.net/fighterandknight/article/details/61240861(分开详细)