2，ArrayList
2024-09-08 10:27:04
一，ArrayList简介
1，ArrayList 是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。
2，ArrayList 继承了AbstractList，实现了List。实现了 List 的一些位置相关操作(比如 get,set,add,remove)。
3，ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。
4，ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
5，ArrayList 实现Serializable接口，说明ArrayList支持序列化。
6，ArrayList不是线程安全的！在多线程中建议选择Vector或者CopyOnWriteArrayList。
二，数据结构
ArrayList的数据结构如下：
底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。对ArrayList类的实例的所有的操作底层都是基于数组的。
三，ArrayList源码
1，ArrayList结构
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
//序列版本号
private static final long serialVersionUID = 8683452581122892189L;
//默认初始容量
private static final int DEFAULT_CAPACITY = 10;
//被用于空实例的共享空数组实例
private static final Object[] EMPTY_ELEMENTDATA = {};
//被用于默认大小的空实例的共享数组实例。
//其与EMPTY_ELEMENTDATA的区别是：当我们向数组中添加第一个元素时，知道数组该扩充多少。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* Object[]类型的数组，保存了添加到ArrayList中的元素。
* ArrayList的容量是该Object[]类型数组的长度。
* 当第一个元素被添加时，任何空的ArrayList中的elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA将会被
* 扩充到DEFAULT_CAPACITY。
*/
transient Object[] elementData;
// ArrayList的实际大小（指其所含的元素个数）
private int size;
省略......
}
1.1，elementData对象
elementData是Object[] 类型的数组，它保存了添加到ArrayList中的元素。
我们通过构造函数 ArrayList(int initialCapacity)来创建时，它的初始容量为initialCapacity。如果通过不含参数的构造函数ArrayList()来创建 ArrayList，则elementData的容量默认是10。
elementData是个动态数组大小会根据ArrayList容量的增长而动态的增长。
1.2，size
动态数组的实际大小。
2，构造函数
ArrayList提供了三种方式的构造器，如下
构造器一：
/**
* 构造一个指定初始容量的空列表
* @param initialCapacity ArrayList的初始容量
* @throws IllegalArgumentException 给定的初始容量为负值，则抛出异常
*/
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() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
构造器三：
/**
* 当传递的参数为集合类型时，会把集合类型转化为数组类型，并赋值给elementData
* @param c 包含用于去构造ArrayList的元素的collection
* @throws NullPointerException 指定的collection为空，则抛出异常
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
if (elementData.getClass() != Object[].class)
//返回一个 Object[].class类型的，大小为size，元素为elementData[0,...,size-1]
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 用空数组替换
this.elementData = EMPTY_ELEMENTDATA;
}
}
3，部分函数
3.1，add()函数
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
// 将e添加到ArrayList的指定位置
public void add(int index, E element) {
//判断下标是否数组越界
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1);
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
在add函数发现其调用了函数ensureCapacityInternal，ensureCapacityInternal的具体函数如下：
private void ensureCapacityInternal(int minCapacity) {
//判断元素数组是否为空数组
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 取较大值
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
在ensureCapacityInternal函数发现其调用了函数ensureExplicitCapacity，ensureExplicitCapacity的具体函数如下：
private void ensureExplicitCapacity(int minCapacity) {
//修改次数+1
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
在ensureExplicitCapacity函数发现其调用了函数grow，grow函数才会对数组进行扩容，grow函数的具体函数如下：
private void grow(int minCapacity) {
int oldCapacity = elementData.length;// 旧容量
int newCapacity = oldCapacity + (oldCapacity >> 1);// 新容量为旧容量的1.5倍
// 判断新容量小于参数指定容量，修改新容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 判断新容量大于最大容量
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);// 指定新容量，特殊情况下（新扩展数组大小已经达到了最大值）则只取最大值。
// 拷贝扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
3.2，remove函数
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（垃圾回收），避免内存泄漏（否则实际上数组中依然有该引用，gc无法进行垃圾回收）
elementData[--size] = null;
// 返回旧值
return oldValue;
}
//该方法能够擦除list中值为null的元素！
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) {
// 修改次数+1
modCount++;
// 需要移动的元素的个数
int numMoved = size - index - 1;
if (numMoved > 0)
//复制数组
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 赋值为空，有利于进行GC（垃圾回收），避免内存泄漏（否则实际上数组中依然有该引用，gc无法进行垃圾回收）
elementData[--size] = null;
}
说明：
|
remove(int index) |
该函数用户移除指定下标的元素，此时会把指定下标到数组末尾的元素向前移动一个单位，并且会把数组最后一个元素设置为null，这样是为了方便之后将整个数组不被使用时，会被GC（垃圾回收）。 |
|
remove(Object o) |
该函数能够擦除list中值为null的元素！ 当然当传进来的元素为null时，循环数组，根据下标判断元素是否为null，如果是null时，调用fastRemove方法。 当然当传进来的元素不为null时，循环数组，调用的是元素的equals方法，如果相等时，能调用fastRemove方法。 |
3.3，removeAll()，retainAll()函数
//删除指定集合的元素
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);//检查参数是否为null
return batchRemove(c, false);
}
//仅保留指定集合的元素
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);//检查参数是否为null
return batchRemove(c, true);
}
3.4，batchRemove()函数
/**
* 根据条件删除/保留指定的元素列表。
* @param complement true时从数组保留指定集合中元素的值，为false时从数组删除指定集合中元素的值。
* @return 数组中重复的元素都会被删除(而不是仅删除一次或几次)，有任何删除操作都会返回true
*/
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
//遍历数组，并检查这个集合是否包含对应的值，移动要保留的值到数组前面，w最后值为要保留的元素的数量
//简单点：若保留，就将相同元素移动到前段；若删除，就将不同元素移动到前段
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
}finally {//确保异常抛出前的部分可以完成期望的操作，而未被遍历的部分会被接到后面
//r!=size表示可能出错了：c.contains(elementData[r])抛出异常
if (r != size) {
System.arraycopy(elementData, r,elementData, w,size - r);
w += size - r;
}
//如果w==size：表示全部元素都保留了，所以也就没有删除操作发生，所以会返回false；反之，返回true，并更改数组
//而w!=size的时候，即使try块抛出异常，也能正确处理异常抛出前的操作，因为w始终为要保留的前段部分的长度，数组也不会因此乱序
if (w != size) {
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;//改变的次数
size = w; //新的大小为保留的元素的个数
modified = true;
}
}
return modified;
}
四，ArrayList遍历方式
ArrayList支持3种遍历方式。
1，迭代器遍历
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
2，随机访问，通过索引值去遍历。
由于ArrayList实现了RandomAccess接口，它支持通过索引值去随机访问元素。
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
3，for循环遍历
for (String string : list) {
System.out.println(string);
}
下面通过一个实例，比较这3种方式的效率，代码如下：
public class Test {
static long startTime = 0;
static long endTime = 0;
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 100000; i++) {
list.add(i + "");
}
Test.loopList_Indexes(list);
Test.loopList_Iterator(list);
Test.loopList_For(list);
}
//随机访问，通过索引值去遍历。
public static void loopList_Indexes(List<String> list){
startTime = System.currentTimeMillis();
for (int i = 0; i < list.size(); i++) {
list.get(i);
}
endTime = System.currentTimeMillis();
long interval = endTime - startTime;
System.out.println("随机访问，通过索引值去遍历(loopList_Indexes)：" + interval + " ms");
}
//通过迭代器遍历
public static void loopList_Iterator(List<String> list){
startTime = System.currentTimeMillis();
for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
iter.next();
}
endTime = System.currentTimeMillis();
long interval = endTime - startTime;
System.out.println("通过迭代器遍历(loopList_Iterator)：" + interval + " ms");
}
//通过for循环遍历
public static void loopList_For(List<String> list){
startTime = System.currentTimeMillis();
String tString;
for (String string : list) {
tString = string;
}
endTime = System.currentTimeMillis();
long interval = endTime - startTime;
System.out.println("通过for循环遍历(loopList_For)：" + interval + " ms");
}
}
运行结果：
由此可见，遍历ArrayList时，使用随机访问(即，通过索引序号访问)效率最高，而使用迭代器的效率最低！
五，常用函数
//因为容量常常会大于实际元素的数量。内存紧张时，可以调用该方法删除预留的位置，调整容量为元素实际数量。
//如果确定不会再有元素添加进来时也可以调用该方法来节约空间
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
}
}
//使用指定参数设置数组容量
public void ensureCapacity(int minCapacity) {
//如果数组为空，容量预取0，否则去默认值(10)
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)? 0: DEFAULT_CAPACITY;
//若参数大于预设的容量，在使用该参数进一步设置数组容量
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
//用于添加元素时，确保数组容量
private void ensureCapacityInternal(int minCapacity) {
//使用默认值和参数中较大者作为容量预设值
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
//如果参数大于数组容量，就增加数组容量
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//数组的最大容量，可能会导致内存溢出(VM内存限制)
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//增加容量，以确保它可以至少持有由参数指定的元素的数目
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//预设容量增加一半
int newCapacity = oldCapacity + (oldCapacity >> 1);
//取与参数中的较大值
if (newCapacity - minCapacity < 0)//即newCapacity<minCapacity
newCapacity = minCapacity;
//若预设值大于默认的最大值检查是否溢出
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
//检查是否溢出，若没有溢出，返回最大整数值(java中的int为4字节，所以最大为0x7fffffff)或默认最大值
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) //溢出
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
//返回数组大小
public int size() {
return size;
}
//是否为空
public boolean isEmpty() {
return size == 0;
}
//是否包含一个数 返回bool
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
//返回一个值在数组首次出现的位置，会根据是否为null使用不同方式判断。不存在就返回-1。时间复杂度为O(N)
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;
}
//返回一个值在数组最后一次出现的位置，不存在就返回-1。时间复杂度为O(N)
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;
}
//返回副本，元素本身没有被复制，复制过程数组发生改变会抛出异常
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
//转换为Object数组，使用Arrays.copyOf()方法
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
//返回一个数组，使用运行时确定类型，该数组包含在这个列表中的所有元素（从第一到最后一个元素）
//返回的数组容量由参数和本数组中较大值确定
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
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;
}
//返回指定位置的值，因为是数组，所以速度特别快
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
//返回指定位置的值，但是会检查这个位置数否超出数组长度
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;
}
//添加一个值，首先会确保容量
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
//指定位置添加一个值，会检查添加的位置和容量
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1);
//public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
//src:源数组； srcPos:源数组要复制的起始位置； dest:目的数组； destPos:目的数组放置的起始位置； length:复制的长度
System.arraycopy(elementData, index, elementData, index + 1,size - index);
elementData[index] = element;
size++;
}
//删除指定位置的值，会检查添加的位置，返回之前的值
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;
}
//删除指定元素首次出现的位置
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++;
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
}
//清空数组，把每一个值设为null,方便垃圾回收(不同于reset，数组默认大小有改变的话不会重置)
public void clear() {
modCount++;
for (int i = 0; i < size; i++) elementData[i] = null;
size = 0;
}
//添加一个集合的元素到末端，若要添加的集合为空返回false
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;
}
//功能同上，从指定位置开始添加
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;
}
//删除指定范围元素。参数为开始删的位置和结束位置
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;
}
//检查数否超出数组长度 用于添加元素时
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//检查是否溢出
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;
}
//删除指定集合的元素
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);//检查参数是否为null
return batchRemove(c, false);
}
//仅保留指定集合的元素
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}
/**
* 源码解读 BY http://anxpp.com/
* @param complement true时从数组保留指定集合中元素的值，为false时从数组删除指定集合中元素的值。
* @return 数组中重复的元素都会被删除(而不是仅删除一次或几次)，有任何删除操作都会返回true
*/
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
//遍历数组，并检查这个集合是否包含对应的值，移动要保留的值到数组前面，w最后值为要保留的元素的数量
//简单点：若保留，就将相同元素移动到前段；若删除，就将不同元素移动到前段
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
}finally {//确保异常抛出前的部分可以完成期望的操作，而未被遍历的部分会被接到后面
//r!=size表示可能出错了：c.contains(elementData[r])抛出异常
if (r != size) {
System.arraycopy(elementData, r,elementData, w,size - r);
w += size - r;
}
//如果w==size：表示全部元素都保留了，所以也就没有删除操作发生，所以会返回false；反之，返回true，并更改数组
//而w!=size的时候，即使try块抛出异常，也能正确处理异常抛出前的操作，因为w始终为要保留的前段部分的长度，数组也不会因此乱序
if (w != size) {
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;//改变的次数
size = w; //新的大小为保留的元素的个数
modified = true;
}
}
return modified;
}
//保存数组实例的状态到一个流（即它序列化）。写入过程数组被更改会抛出异常
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();
}
}
//上面是写，这个就是读了。
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// 执行默认的序列化/反序列化过程
s.defaultReadObject();
// 读入数组长度
s.readInt();
if (size > 0) {
ensureCapacityInternal(size);
Object[] a = elementData;
//读入所有元素
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
//返回ListIterator，开始位置为指定参数
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
//返回ListIterator，开始位置为0
public ListIterator<E> listIterator() {
return new ListItr(0);
}
//返回普通迭代器
public Iterator<E> iterator() {
return new Itr();
}
//通用的迭代器实现
private class Itr implements Iterator<E> {
int cursor; //游标，下一个元素的索引，默认初始化为0
int lastRet = -1; //上次访问的元素的位置
int expectedModCount = modCount;//迭代过程不运行修改数组，否则就抛出异常
//是否还有下一个
public boolean hasNext() {
return cursor != size;
}
//下一个元素
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();//检查数组是否被修改
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
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) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
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();
}
//检查数组是否被修改
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
//ListIterator迭代器实现
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;
}
public int previousIndex() {
return cursor - 1;
}
@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;
return (E) elementData[lastRet = i];
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
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);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
//返回指定范围的子数组
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
常用函数注释
最新文章
- python中使用heapq查看最大与最小的N个元素列表
- IE7浏览器窗口大小改变事件执行多次bug（转）
- 文本编辑的css常用属性
- Oracle添加数据报文字与格式字符串不匹配错误
- Android - 控件android:ems属性
- Javascript中括号“[]”的多义性
- [内核同步]Linux内核同步机制之completion
- php 扩展dll
- java socket 一个服务器对应多个客户端，可以互相发送消息
- MariaDB-5.5.32源码编译安装
- Android之fragment点击切换和滑动切换结合
- 基于visual Studio2013解决算法导论之030二叉查找树
- js中对节点属性的操作和对节点的操作
- 基于windows环境的Flask网站搭建（mysql + conda + redis）
- [dev] Go语言查看doc与生成API doc
- JavaScript权威指南--数组Array
- XWIKI离线WAR包部署(LDAP登录)
- Python学习第十三篇——函数的深层次运用
- luogu3263/bzoj4002 有意义的字符串 (数学+矩阵快速幂)
- 删除一个存在的RabbitMQ队列
热门文章
- Non-local Neural Networks
- ThreadPoolExecutor 源码分析
- DelayQueue 源码分析
- 【ABAP系列】SAP ALV 导出报表数据 始终使用选定的格式”，一旦勾上，就再也不会弹出选择框了。
- 刷题——有重复元素的全排列（Permutations II）
- String类为什么是final
- （4.30）全面了解触发器：DML、DDL、LOGON触发器
- 总结：String类型与Int类型的转换【实现插入操作主键自增】
- Codeforces 1159D The minimal unique substring（构造）
- JavaScript、ES6中的类的继承