packagejava.util;importjava.util.function.Consumer;importjava.util.function.Predicate;importjava.util.function.UnaryOperator;importsun.misc.SharedSecrets;//其中实现了RandomAccess接口表示支持随机访问
public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable
{//序列号
private static final long serialVersionUID = 8683452581122892189L;/*** 默认初始容量*/
private static final int DEFAULT_CAPACITY = 10;/*** 共享的空数组实例(用于空实例)
* 当ArrayList(int initialCapacity)，ArrayList(Collection extends E> c)中的容量等于0的时候使用*/
private static final Object[] EMPTY_ELEMENTDATA ={};/*** 共享的空数组实例(用于默认大小的空实例)
* 将其与EMPTY_ELEMENTDATA区分开来，主要是为了知道第一次添加元素的时候需要扩容多少
* 用于ArrayList()构造器*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA ={};/*** ArrayList保存有序元素的数组
* ArraylList容量为数组容量
* 任何空数组都使用 elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* 当第一次添加元素的时候其容量将会扩容至 DEFAULT_CAPACITY(10)*/
transient Object[] elementData; //non-private to simplify nested class access
/*** ArrayList的大小(包含元素的数量)
*@serial
*/
private intsize;/*** 带指定容量参数的构造器，如果元素数量较大的话，可以使用此构造器，防止频繁扩容造成的性能损失*/
public ArrayList(intinitialCapacity) {//如果传入值大于0，则创建一个该容量大小的数组。
if (initialCapacity > 0) {this.elementData = newObject[initialCapacity];
}else if (initialCapacity == 0) {//否则如果传入值等于0，则创建默认空数组
this.elementData =EMPTY_ELEMENTDATA;
}else{//如果小于0则抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
}
}/*** 默认构造函数，其初始容量为10(注意，这里一开始其实是一个空数组，只是当add时才会进行扩容至10的操作，一定程度上减小了内存消耗。)*/
publicArrayList() {this.elementData =DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}/*** 构造一个包含指定集合元素的列表，元素顺序由集合的迭代器所返回。*/
public ArrayList(Collection extends E>c) {//集合转数组
elementData =c.toArray();//指定集合含有元素
if ((size = elementData.length) != 0) {//c.toArray可能不会返回Object[] (see 6260652)//使用反射进行运行时判断elementData是否属于Object[]
if (elementData.getClass() != Object[].class)//拷贝数组
elementData = Arrays.copyOf(elementData, size, Object[].class);
}else{//由空数组代替
this.elementData =EMPTY_ELEMENTDATA;
}
}/*** 修改ArrayList容量为list的当前大小
* 一个应用可以使用此操作来最小化一个ArrayList的存储*/
public voidtrimToSize() {
modCount++;//如果当前数组元素个数小于数组容量
if (size
elementData = (size == 0)?EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}/*** 如果有必要去增加ArrayList的容量，请确保它至少可以容纳由最小容量参数指定的元素数量
*@paramminCapacity 所需的最小容量*/
public void ensureCapacity(intminCapacity) {//默认最小容量，空数组以及默认大小10
int minExpand = (elementData !=DEFAULTCAPACITY_EMPTY_ELEMENTDATA)//any size if not default element table
? 0
//larger than default for default empty table. It's already//supposed to be at default size.
: DEFAULT_CAPACITY;//如果传入容量大于最小容量，则进行扩容
if (minCapacity >minExpand) {
ensureExplicitCapacity(minCapacity);
}
}private static int calculateCapacity(Object[] elementData, intminCapacity) {//如果elementData为默认空数组，则比较传入值与默认值(10)，返回两者中的较大值//elementData为默认空数组指的是通过ArrayList()这个构造器创建的ArrayList对象
if (elementData ==DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {returnMath.max(DEFAULT_CAPACITY, minCapacity);
}//返回传入值
returnminCapacity;
}private void ensureCapacityInternal(intminCapacity) {//先通过calculateCapacity方法计算最终容量，以确认实际容量
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}private void ensureExplicitCapacity(intminCapacity) {
modCount++;//overflow-conscious code//如果最终确认容量大于数组容量，则进行grow()扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}/*** 可分配数组最大大小*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;/*** 增加ArrayList的容量，以确保它至少可以容纳由最小容量参数指定的元素数量
*@paramminCapacity 所需的最小容量*/
private void grow(intminCapacity) {//overflow-conscious code//oldCapacity表示旧容量
int oldCapacity =elementData.length;//newCapacity表示新容量，计算规则为旧容量+旧容量的0.5，即旧容量的1.5倍。如果超过int的最大值会返回一个负数。//oldCapacity >> 1表示右移一位，对应除以2的1次方。
int newCapacity = oldCapacity + (oldCapacity >> 1);//如果新容量小于最小容量，则将最小容量赋值给新容量(有时手动扩容可能也会返回<0，对应方法为ensureCapacity())
if (newCapacity - minCapacity < 0)
newCapacity=minCapacity;//如果新容量大于MAX_ARRAY_SIZE，则执行hugeCapacity(minCapacity)返回对应值
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity=hugeCapacity(minCapacity);//minCapacity is usually close to size, so this is a win://复制旧数组到新容量数组中，完成扩容操作
elementData =Arrays.copyOf(elementData, newCapacity);
}private static int hugeCapacity(intminCapacity) {//如果最小容量超过了int的最大值，minCapacity会是一个负数，此时抛出内存溢出错误
if (minCapacity < 0) //overflow
throw newOutOfMemoryError();//比较最小容量是否大于MAX_ARRAY_SIZE，如果是则返回Integer.MAX_VALUE，否则返回MAX_ARRAY_SIZE
return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}/*** 返回列表元素数*/
public intsize() {returnsize;
}/*** 如果列表不包含元素，返回true*/
public booleanisEmpty() {return size == 0;
}/*** 如果列表包含指定元素，返回true*/
public booleancontains(Object o) {//返回此列表中指定元素第一次出现的索引，如果列表中不包含指定元素，则为-1
return indexOf(o) >= 0;
}/*** 返回此列表中指定元素第一次出现的索引，如果列表中不包含指定元素，则为-1*/
public intindexOf(Object o) {if (o == null) {for (int i = 0; i < size; i++)if (elementData[i]==null)returni;
}else{for (int i = 0; i < size; i++)if(o.equals(elementData[i]))returni;
}return -1;
}/*** 返回此列表中指定元素最后一次出现的索引，如果列表中不包含指定元素，则为-1*/
public intlastIndexOf(Object o) {if (o == null) {for (int i = size-1; i >= 0; i--)if (elementData[i]==null)returni;
}else{for (int i = size-1; i >= 0; i--)if(o.equals(elementData[i]))returni;
}return -1;
}/*** 返回ArrayList实例的一个浅拷贝，列表中的元素不会被拷贝*/
publicObject clone() {try{
ArrayList> v = (ArrayList>) super.clone();
v.elementData=Arrays.copyOf(elementData, size);
v.modCount= 0;returnv;
}catch(CloneNotSupportedException e) {//this shouldn't happen, since we are Cloneable
throw newInternalError(e);
}
}/*** 以正确的顺序(从第一个到最后一个元素)返回一个包含此列表中所有元素的数组。
* 返回的数组将是“安全的”，因为该列表不保留对它的引用。 (换句话说，这个方法必须分配一个新的数组)。
* 因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。*/
publicObject[] toArray() {returnArrays.copyOf(elementData, size);
}/*** 以正确的顺序返回一个包含此列表中所有元素的数组(从第一个到最后一个元素);
* 返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。
* 否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。
* 如果列表适用于指定的数组，其余空间(即数组的列表数量多于此元素)，则紧跟在集合结束后的数组中的元素设置为null 。
*(这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。)*/@SuppressWarnings("unchecked")public T[] toArray(T[] a) {if (a.length
return(T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData,0, a, 0, size);if (a.length >size)
a[size]= null;returna;
}//位置访问操作
@SuppressWarnings("unchecked")
E elementData(intindex) {return(E) elementData[index];
}/*** 返回此列表中指定位置的元素*/
public E get(intindex) {//检查索引是否越界
rangeCheck(index);returnelementData(index);
}/*** 用指定元素替换列表中的指定位置的元素*/
public E set(intindex, E element) {//检查索引是否越界
rangeCheck(index);
E oldValue=elementData(index);
elementData[index]=element;returnoldValue;
}/*** 将指定元素追加到数组末尾*/
public booleanadd(E e) {//添加之前先确认是否需要扩容
ensureCapacityInternal(size + 1); //Increments modCount!!//新加入的元素是添加在了数组的末尾，随后数组size自增。
elementData[size++] =e;return true;
}/*** 插入指定元素到此列表中的指定位置
* 先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
* 再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。*/
public void add(intindex, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size+ 1); //Increments modCount!!//自己复制自己
System.arraycopy(elementData, index, elementData, index + 1,
size-index);
elementData[index]=element;
size++;
}/*** 将列表中指定位置的元素移除，后续所有元素移到左端(从他们的索引中减去一个)*/
public E remove(intindex) {
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; //清理工作交给GC
returnoldValue;
}/*** 从列表中移除第一次出现的指定元素，如果不存在，则不更改*/
public booleanremove(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 remove method that skips bounds checking and does not
* return the value removed.*/
private void fastRemove(intindex) {
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
}/*** 移除列表中的所有元素，之后会返回一个空数组*/
public voidclear() {
modCount++;//clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i]= null;
size= 0;
}/*** 将指定集合中的元素以Iterator返回的顺序，追加到列表末尾*/
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;
}/*** 将指定集合中的元素以Iterator返回的顺序，插入到指定位置*/
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;
}/*** 移除[fromIndex,toIndex)之间的元素，后续元素移到左端*/
protected void removeRange(int fromIndex, inttoIndex) {
modCount++;int numMoved = size -toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);//clear to let GC do its work
int newSize = size - (toIndex-fromIndex);for (int i = newSize; i < size; i++) {
elementData[i]= null;
}
size=newSize;
}/***检查给定索引是否在界限内。*/
private void rangeCheck(intindex) {if (index >=size)throw newIndexOutOfBoundsException(outOfBoundsMsg(index));
}/*** add and addAll使用的rangeCheck*/
private void rangeCheckForAdd(intindex) {if (index > size || index < 0)throw newIndexOutOfBoundsException(outOfBoundsMsg(index));
}/*** 返回 an IndexOutOfBoundsException 的细节信息*/
private String outOfBoundsMsg(intindex) {return "Index: "+index+", Size: "+size;
}/*** 从列表中移除指定集合包含的所有元素*/
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, booleancomplement) {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) {//clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i]= null;
modCount+= size -w;
size=w;
modified= true;
}
}returnmodified;
}/*** 保存ArrayList状态到一个流中(即序列化)*/
private voidwriteObject(java.io.ObjectOutputStream s)throwsjava.io.IOException{//Write out element count, and any hidden stuff
int expectedModCount =modCount;
s.defaultWriteObject();//Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);//Write out all elements in the proper order.
for (int i=0; i
s.writeObject(elementData[i]);
}if (modCount !=expectedModCount) {throw newConcurrentModificationException();
}
}/*** 从一个流中读取ArrayList(即反序列化)*/
private voidreadObject(java.io.ObjectInputStream s)throwsjava.io.IOException, ClassNotFoundException {
elementData=EMPTY_ELEMENTDATA;//Read in size, and any hidden stuff
s.defaultReadObject();//Read in capacity
s.readInt(); //ignored
if (size > 0) {//be like clone(), allocate array based upon size not capacity
int capacity =calculateCapacity(elementData, size);
SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
ensureCapacityInternal(size);
Object[] a=elementData;//Read in all elements in the proper order.
for (int i=0; i
a[i]=s.readObject();
}
}
}/*** 从列表中的指定位置开始，返回之后所有元素的列表迭代器(按正确的顺序)
* 指定的索引表示初始调用将返回的第一个元素为next 。 初始调用previous将返回指定索引减1的元素。
* 返回的列表迭代器是fail-fast 。*/
public ListIterator listIterator(intindex) {if (index < 0 || index >size)throw new IndexOutOfBoundsException("Index: "+index);return newListItr(index);
}/*** 返回列表中的包含所有元素的列表迭代器(按正确的顺序)。
* 返回的列表迭代器是fail-fast 。*/
public ListIteratorlistIterator() {return new ListItr(0);
}/*** 以正确的顺序返回列表中的包含所有元素的迭代器。
* 返回的迭代器是fail-fast 。*/
public Iteratoriterator() {return newItr();
}
@Overridepublic void forEach(Consumer super E>action) {
Objects.requireNonNull(action);final int expectedModCount =modCount;
@SuppressWarnings("unchecked")final E[] elementData = (E[]) this.elementData;final int size = this.size;for (int i=0; modCount == expectedModCount && i < size; i++) {
action.accept(elementData[i]);
}if (modCount !=expectedModCount) {throw newConcurrentModificationException();
}
}
@Overridepublic boolean removeIf(Predicate super E>filter) {
Objects.requireNonNull(filter);//figure out which elements are to be removed//any exception thrown from the filter predicate at this stage//will leave the collection unmodified
int removeCount = 0;final BitSet removeSet = newBitSet(size);final int expectedModCount =modCount;final int size = this.size;for (int i=0; modCount == expectedModCount && i < size; i++) {
@SuppressWarnings("unchecked")final E element =(E) elementData[i];if(filter.test(element)) {
removeSet.set(i);
removeCount++;
}
}if (modCount !=expectedModCount) {throw newConcurrentModificationException();
}//shift surviving elements left over the spaces left by removed elements
final boolean anyToRemove = removeCount > 0;if(anyToRemove) {final int newSize = size -removeCount;for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
i=removeSet.nextClearBit(i);
elementData[j]=elementData[i];
}for (int k=newSize; k < size; k++) {
elementData[k]= null; //Let gc do its work
}this.size =newSize;if (modCount !=expectedModCount) {throw newConcurrentModificationException();
}
modCount++;
}returnanyToRemove;
}
@Override
@SuppressWarnings("unchecked")public void replaceAll(UnaryOperatoroperator) {
Objects.requireNonNull(operator);final int expectedModCount =modCount;final int size = this.size;for (int i=0; modCount == expectedModCount && i < size; i++) {
elementData[i]=operator.apply((E) elementData[i]);
}if (modCount !=expectedModCount) {throw newConcurrentModificationException();
}
modCount++;
}
@Override
@SuppressWarnings("unchecked")public void sort(Comparator super E>c) {final int expectedModCount =modCount;
Arrays.sort((E[]) elementData,0, size, c);if (modCount !=expectedModCount) {throw newConcurrentModificationException();
}
modCount++;
}
}
304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
