ArrayList源碼

時間 2019-11-10

標籤 arraylist 源碼欄目 Java 简体版

原文原文鏈接

package java.util;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
/**
* 能夠改變大小的List的實現，實現全部的List的操做，容許保存各類元素，包括null。除了實現
* List接口以外，這個類提供了操做內部存儲數據的數組大小的方法。（這個類至關於Vector，
* 可是它並非線程同步的，不是線程安全的）
*
* size,isEmpty,set,iterator,listIterator方法運行時間爲常量時間，add方法運行爲攤還常量
* 時間，也即增長n個元素的時間爲O(n)。其餘的操做運行時間大體爲線性時間，常數因子相較
* 於LinkedList更小
*
* 每一個ArrayList實例都有一個容量，是存儲數據的數組的大小，他至少是List的元素數量的大小。
* 隨着元素的增長，容量自動增長。容量增大的細節在添加一個元素有恆定的時間成本攤銷的基礎上
*
* 在添加大量元素前，應用程序可使用ensureCapacity方法增大Arraylist的容量，這可能減小
* 增量從新分配的次數
*
* 這個實現是非線程安全的，若是有多個線程同時操做一個ArrayList實例，其中至少有一個線程
* 在修改這個實例的結構，則必須在外部使用同步控制（一個結構上的修改操做指的是添加或刪除一個
* 或多個元素，或者明確改變存儲數據的數組大小，僅僅改變元素值不是結構上的修改），這通常由
* 封裝ArrayList的類來進行。
*
* 若是沒有這樣的對象存在，列表應該使用Collections.synchronizedList方法來得到同步的
* （線程安全的）裝飾對象（代理對象）。這個操做最好在建立的時候進行，來防止意外的非同步的
* 操做。還可使用concurrent包下的CopyOnWriteArrayList代替ArrayList的使用
*
*
* 使用類的iterator（)和listIterator(int)方法會出發fail-fast錯誤機制（拋出
* ConcurrentModificationException異常），若是建立了iterator後進行結構上的修改，除了使
* 用iterator的remove或者add方法。所以，在併發修改時，iterator快速失敗而且清除，而不是冒
* 着未來可能發生的不肯定的風險。
*
* 迭代器的fail-fast錯誤機制不能被保證，一般來講，很難保證在非同步併發修改操做的fail-fast
* 機制。fail-fast錯誤機制的迭代器力所能及的拋出ConcurrentModificationException。
* 因此，開發時不該該依賴這個異常保證程序的正確性，僅僅在發現bug時使用
* 繼承了AbstractList，能夠繼承部分默認的實現
* 實現了Cloneable, java.io.Serializable，容許克隆和序列化
*/
publicclassArrayList<E>extendsAbstractList<E>
implementsList<E>,RandomAccess,Cloneable, java.io.Serializable
{
//序列號
privatestaticfinallong serialVersionUID =8683452581122892189L;
/**
* 列表默認容量
*/
privatestaticfinalint DEFAULT_CAPACITY =10;
/**
* 共享空數組實例，用於空實例。調用構造函數容量爲0時，會賦予數據的數組
*/
privatestaticfinalObject[] EMPTY_ELEMENTDATA ={};
/**
* 共享空數組實例用於默認大小的空實例。使用默認構造函數時，會賦予數據的數組
*/
privatestaticfinalObject[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA ={};
/**
* 存儲數據的數組，數組大小就是列表的容量的大小。在第一次加入元素時，任何空實例
* （DEFAULTCAPACITY_EMPTY_ELEMENTDATA）會擴充成默認大小。
* transient表示序列化過程不但願被序列化的字段，ArrayList本身實現的序列化機制會
* 逐個序列化每一個元素
*/
transientObject[] elementData;// non-private to simplify nested class access
/**
* 列表中元素的數量
*
* @serial
*/
privateint size;
/**
* 構造一個指定容量的空列表
*
* @param initialCapacity 列表的初始容量
* @throws IllegalArgumentException 傳入的初始容量爲負數時，拋出次異常
*/
publicArrayList(int initialCapacity){
if(initialCapacity >0){
this.elementData =newObject[initialCapacity];
}elseif(initialCapacity ==0){
this.elementData = EMPTY_ELEMENTDATA;
}else{
thrownewIllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
* 構造一個默認大小的空列表
*/
publicArrayList(){
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 根據傳入的集合，構造一個列表，元素的順序是傳入集合的迭代器返回的順序
*
* @param c 傳入的容器
* @throws NullPointerException 傳入的容器爲空時拋出異常
*/
publicArrayList(Collection<?extends E> c){
elementData = c.toArray();
if((size = elementData.length)!=0){
// c.toArray()可能沒有返回 Object[]
if(elementData.getClass()!=Object[].class)
//轉成Object類型
elementData =Arrays.copyOf(elementData, size,Object[].class);
}else{
// 若是傳入的集合沒有元素，則使用空數組代替
this.elementData = EMPTY_ELEMENTDATA;
}
}
/**
* 減少列表的容器大小至列表中元素數量
*/
publicvoid trimToSize(){
modCount++;
if(size < elementData.length){
elementData =(size ==0)
? EMPTY_ELEMENTDATA
:Arrays.copyOf(elementData, size);
}
}
/**
* 增大ArrayList實例的容量, 若是必要，保證可以存儲傳入的最小容量個元素
*
* @param minCapacity 須要的最少的存儲容量
*/
publicvoid ensureCapacity(int minCapacity){
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);
}
}
privatevoid ensureCapacityInternal(int minCapacity){
//默認大小數組，將數組擴展成默認或者minCapacity的大的容量
if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA){
minCapacity =Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
//確保數組可以保存足夠的元素
privatevoid ensureExplicitCapacity(int minCapacity){
modCount++;
// 當要求的數量大於數組的大小，擴充成須要的數量
if(minCapacity - elementData.length >0)
grow(minCapacity);
}
/**
* 最大容許的容量
* 一些虛擬機會存儲一些頭信息
* 嘗試分配大容量的數組會致使OutOfMemoryError，超出虛擬機的限制
*/
privatestaticfinalint MAX_ARRAY_SIZE =Integer.MAX_VALUE -8;
/**
* 擴充容量以保證可以存儲須要的容量（傳入的參數）
*
* @param minCapacity 須要的容量大小
*/
privatevoid grow(int minCapacity){
// overflow-conscious code
int oldCapacity = elementData.length;
//擴充原來容量的1/2，即擴大1.5倍
int newCapacity = oldCapacity +(oldCapacity >>1);
//若是須要的容量仍是不夠，則擴充至須要的容量的大小
if(newCapacity - minCapacity <0)
newCapacity = minCapacity;
/**
* 若是超出定義的最大容量，擴充至定義的最大容量（須要的容量小於等於定義的最大
* 容量）或最大int的值（須要的容量大小大於定義的最大容量）
* */
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);
}
// 根據須要的容量大小，得到超大容量
privatestaticint hugeCapacity(int minCapacity){
if(minCapacity <0)// 若是minCapacity小於0，則超出最大整數值
thrownewOutOfMemoryError();
return(minCapacity > MAX_ARRAY_SIZE)?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
/**
* 返回列表的中元素的數量
*
* @return 列表的中元素的數量
*/
publicint size(){
return size;
}
/**
* 判斷列表是否爲空
*
* @return 當列表中沒有元素則返回true，不然返回false
*/
publicboolean isEmpty(){
return size ==0;
}
/**
* 當列表中存在傳入的元素，返回true。進一步，列表中至少有一個傳入的元素，則返回true
* 好比 o爲null，則判斷列表中是否有null元素，返回o與列表中的元素e的equals()比較的結果
*
* @param 須要檢驗是否在列表中的元素的對象
* @return 若是列表中存在o則返回true
*/
publicboolean contains(Object o){
return indexOf(o)>=0;
}
/**
* 返回列表中第一次出現的o（equals方法返回true）的索引，若是不存在則返回-1
*/
publicint 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;
}
/**
* 返回列表中最後一次出現的o（equals方法返回true）的索引，若是不存在則返回-1
*/
publicint 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;
}
/**
* 返回ArrayList實例的淺表複製，不復制列表的元素（都指向相同的對象，沒有建立新的對
* 象）。
*/
publicObject clone(){
try{
ArrayList<?> v =(ArrayList<?>)super.clone();
v.elementData =Arrays.copyOf(elementData, size);
v.modCount =0;
return v;
}catch(CloneNotSupportedException e){
// this shouldn't happen, since we are Cloneable
thrownewInternalError(e);
}
}
/**
* 得到按照列表順序存儲的數組，這個方法須要分配內存存儲拷貝的數組。（淺複製）
*
* @return an array containing all of the elements in this list in
* proper sequence
*/
publicObject[] toArray(){
returnArrays.copyOf(elementData, size);
}
/**
* 得到按照列表順序存儲的數組，返回一個泛型數組，這個方法須要分配內存存儲拷貝的數組
* （淺複製），返回的數組的類型應該是參數指定的類型。若是傳入的數組大小大於列表的元素
* 則返回，傳入的數組，不然建立一個新的數組，並返回新建立的數組
*
* 若是傳入的數組長度大於列表的長度，則設置其第size個元素爲null（當且僅當在知道list中
* 沒有null元素時，用於判斷list中元素個數）
* @param a 若是足夠大，存儲列表中的元素，不然根據傳入的運行時參數建立一個新的數組
* @return 返回列表元素的一個拷貝
* @throws ArrayStoreException if the runtime type of the specified array
* is not a supertype of the runtime type of every element in
* this list
* @throws NullPointerException if the specified array is null
*/
@SuppressWarnings("unchecked")
public<T> T[] toArray(T[] a){
if(a.length < size)
// Make a new array of a's runtime type, but my contents:
return(T[])Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData,0, a,0, size);
if(a.length > size)
a[size]=null;
return a;
}
/**
* 根據索引，得到列表中第index個元素，首先檢查下標是否在正確的範圍
*/
@SuppressWarnings("unchecked")
E elementData(int index){
return(E) elementData[index];
}
/**
* 返回第index個元素
*
* @param index index of the element to return
* @return the element at the specified position in this list
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E get(int index){
rangeCheck(index);
return elementData(index);
}
/**
* 將第index個元素的值修改成傳入的元素值，首先檢查下標是否在正確的範圍，返回修改前的值
*
* @param index 元素的索引
* @param element 設置到index的值
* @return 原來位於index的值
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E set(int index, E element){
rangeCheck(index);
E oldValue = elementData(index);
elementData[index]= element;
return oldValue;
}
/**
* 在列表的末尾添加元素，修改列表的元素數量（size）。首先須要確保列表的容量足夠存放新
* 添加的元素。
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
publicboolean add(E e){
ensureCapacityInternal(size +1);// 確保可以存放添加元素，容量不足則擴容
elementData[size++]= e;
returntrue;
}
/**
* 在列表第index個位置插入一個元素，index及其後面的元素向後移動一個位置，而後將須要插
* 入的值存入第index的位置
*
* @param index index at which the specified element is to be inserted
* @param element element to be inserted
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
publicvoid add(int index, E element){
rangeCheckForAdd(index);
ensureCapacityInternal(size +1);// 確保有足夠的存儲空間
System.arraycopy(elementData, index, elementData, index +1,
size - index);
elementData[index]= element;
size++;
}
/**
* 移除列表中第index個元素，index後面的元素向前移動一個位置，列表元素數量減少1
*
* @param index 移除的元素的下標
* @return 返回被刪除的元素
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
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;
}
/**
* 移除列表中第一個o（o爲null時，第一個null元素，不然，是第一個equals()爲true的元
* 素），若是過不存在，則不改變。若是列表中存在這樣的元素，則返回true，不然返回false
*
* @param o element to be removed from this list, if present
* @return <tt>true</tt> if this list contained the specified element
*/
publicboolean remove(Object o){
if(o ==null){
for(int index =0; index < size; index++)
if(elementData[index]==null){
fastRemove(index);
returntrue;
}
}else{
for(int index =0; index < size; index++)
if(o.equals(elementData[index])){
fastRemove(index);
returntrue;
}
}
returnfalse;
}
/*
* 快速移除元素，不檢查索引範圍，不返回被刪除元素
*/
privatevoid fastRemove(int index){
modCount++;
int numMoved = size - index -1;
if(numMoved >0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size]=null;// 釋放，以讓垃圾回收器回收
}
/**
* 移除列表中全部的元素，操做後，列表爲空
*/
publicvoid clear(){
modCount++;
// 釋放全部引用，以讓垃圾收集器回收
for(int i =0; i < size; i++)
elementData[i]=null;
//列表大小改成0
size =0;
}
/**
* 向列表末尾添加c中的全部元素，順序是c.iterator()返回的順序，添加了元素返回true。
*
* @param c collection containing elements to be added to this list
* @return <tt>true</tt> if this list changed as a result of the call
* @throws NullPointerException if the specified collection is null
*/
publicboolean 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;
}
/**
* 向列表第index位置起添加c中的全部元素，順序是c.iterator()返回的順序，index及其後面
* 的元素向後移動c中元素個位置，添加了元素返回true。首先須要檢查index是不是在範圍內
*
* @param index index at which to insert the first element from the
* specified collection
* @param c collection containing elements to be added to this list
* @return <tt>true</tt> if this list changed as a result of the call
* @throws IndexOutOfBoundsException {@inheritDoc}
* @throws NullPointerException if the specified collection is null
*/
publicboolean 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)範圍的元素，不包括toIndex
*
* @throws IndexOutOfBoundsException if {@code fromIndex} or
* {@code toIndex} is out of range
* ({@code fromIndex < 0 ||
* fromIndex >= size() ||
* toIndex > size() ||
* toIndex < fromIndex})
*/
protectedvoid 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;
}
/**
* 檢查索引值是否在合理的範圍內，不在則拋出異常
* negative: It is always used immediately prior to an array access,
* which throws an ArrayIndexOutOfBoundsException if index is negative.
*/
privatevoid rangeCheck(int index){
if(index >= size)
thrownewIndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 檢查索引值是否在合理的範圍內，不在則拋出異常
*/
privatevoid rangeCheckForAdd(int index){
if(index > size || index <0)
thrownewIndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 生成數組越界異常信息
*/
privateString outOfBoundsMsg(int index){
return"Index: "+index+", Size: "+size;
}
/**
* 移除列表中的c中包含的全部元素
*
* @param c 須要移除的元素集合，不能爲空
* @return 若是列表改變了，則返回true，不然返回false
* @throws ClassCastException 若是傳入的集合中有與列表中元素類型不匹配時，拋出該異
* 常
* @throws NullPointerException ArrayList不支持null，但c中包含null元素時，拋出該
* 異常
*/
publicboolean removeAll(Collection<?> c){
Objects.requireNonNull(c);
return batchRemove(c,false);
}
/**
* 保留列表中與c中共有的元素（求交集）。
*
* @param c 須要完成交集的集合，不容許爲空
* @return 若是列表改變了，則返回true，不然返回false
* @throws ClassCastException 若是傳入的集合中有與列表中元素類型不匹配時，拋出該異
* 常
* @throws NullPointerException ArrayList不支持null，但c中包含null元素時，拋出該
* 異常
*/
publicboolean retainAll(Collection<?> c){
Objects.requireNonNull(c);
return batchRemove(c,true);
}
/**
* 批量刪除, complement爲true時，保留與c中相同的元素，不然，保留與c中不相同的元素
*/
privateboolean batchRemove(Collection<?> c,boolean complement){
finalObject[] 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{
//保護動做，當c.contains()拋出異常時，將剩餘的（r以後的）元素保留
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實例的狀態保存到流中，也即序列化，這是類實現的序列化機制，不是默認
* 的序列化機制
*
* @serialData The length of the array backing the <tt>ArrayList</tt>
* instance is emitted (int), followed by all of its elements
* (each an <tt>Object</tt>) in the proper order.
*/
privatevoid writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();//默認序列化，記錄列表中元素的個數
// 將列表大小做爲容量保存，以此適用於clone()
s.writeInt(size);
// 按照正確順序保存列表中的元素
for(int i=0; i<size; i++){
s.writeObject(elementData[i]);
}
//序列化過程當中是否有修改列表的結構（擴容，添加，移除操做）
//若是有，則拋出ConcurrentModificationException異常
if(modCount != expectedModCount){
thrownewConcurrentModificationException();
}
}
/**
* 從流中讀取並從新建立Arraylist，也即反序列化
*/
privatevoid readObject(java.io.ObjectInputStream s)
throws java.io.IOException,ClassNotFoundException{
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();//默認反序列化，讀取列表元素個數
// 讀取容量，忽略
s.readInt();// ignored
if(size >0){
// 相似於clone()，建立大小與元素個數相同的數組
ensureCapacityInternal(size);
Object[] a = elementData;
// 以正確的順序讀取全部的元素
for(int i=0; i<size; i++){
a[i]= s.readObject();
}
}
}
/**
* 建立一個從index開始的ListIterator（第一次調用next，返回index處的元素），調用
* previous，則返回index-1處的元素，首先檢查index的正確性
*
* The returned list iterator is fail-fast
*
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
publicListIterator<E> listIterator(int index){
if(index <0|| index > size)
thrownewIndexOutOfBoundsException("Index: "+index);
returnnewListItr(index);
}
/**
* 重載，建立一個默認從0開始的ListIterator
*
* The returned list iterator is fail-fast
*
* @see #listIterator(int)
*/
publicListIterator<E> listIterator(){
returnnewListItr(0);
}
/**
* 按照正確的順序，產生一個iterator
*
* @return an iterator over the elements in this list in proper sequence
*/
publicIterator<E> iterator(){
returnnewItr();
}
/**
* AbstractList.Itr的優化
*/
privateclassItrimplementsIterator<E>{
int cursor;// 下一個元素的遊標（索引）
int lastRet =-1;// 上一次返回的元素的索引
int expectedModCount = modCount;
//是否存在下一個，沒有遍歷到末尾，返回true
publicboolean hasNext(){
return cursor != size;
}
//返回下一個元素
@SuppressWarnings("unchecked")
public E next(){
//檢查迭代器過程當中，是否有修改ArrayList的實例的結構
//有則拋出ConcurrentModificationException異常
checkForComodification();
int i = cursor;
if(i >= size)
thrownewNoSuchElementException();//超出size範圍，則拋出異常
Object[] elementData =ArrayList.this.elementData;
if(i >= elementData.length)
thrownewConcurrentModificationException();
cursor = i +1;//記錄下一個元素的遊標值
return(E) elementData[lastRet = i];
}
//移除當前的元素（next()得到的元素，cursor已經指向下一個）
publicvoid remove(){
//上一個元素不存在
if(lastRet <0)
thrownewIllegalStateException();
checkForComodification();//檢查是否修改
try{
ArrayList.this.remove(lastRet);//移除lastRet處的元素
cursor = lastRet;
lastRet =-1;
expectedModCount = modCount;
}catch(IndexOutOfBoundsException ex){
thrownewConcurrentModificationException();
}
}
/**
* 對剩餘未迭代的元素進行指定操做，直到全部的元素都已經被處理或行動將拋出一個異常
*/
@Override
@SuppressWarnings("unchecked")
publicvoid forEachRemaining(Consumer<?super E> consumer){
Objects.requireNonNull(consumer);
finalint size =ArrayList.this.size;
int i = cursor;
//已經遍歷完成，不須要繼續遍歷
if(i >= size){
return;
}
finalObject[] elementData =ArrayList.this.elementData;
if(i >= elementData.length){
thrownewConcurrentModificationException();
}
while(i != size && modCount == expectedModCount){
consumer.accept((E) elementData[i++]);
}
// 更新遊標和上一次返回的元素，並檢測是否修改了列表結構
cursor = i;
lastRet = i -1;
checkForComodification();
}
finalvoid checkForComodification(){
if(modCount != expectedModCount)
thrownewConcurrentModificationException();
}
}
/**
* AbstractList.ListItr的優化，繼承自Iter
*/
privateclassListItrextendsItrimplementsListIterator<E>{
ListItr(int index){
super();
cursor = index;//指定第一個須要返回的元素爲index
}
//返回是否有前一個元素，直到到列表的第0個元素
publicboolean hasPrevious(){
return cursor !=0;
}
//返回下一個元素的遊標
publicint nextIndex(){
return cursor;
}
//返回上一個元素的遊標
publicint previousIndex(){
return cursor -1;
}
//獲取上一個元素
@SuppressWarnings("unchecked")
public E previous(){
checkForComodification();//檢查是否修改了列表的結構
int i = cursor -1;//得到上一個元素索引
//數組越界則拋出異常
if(i <0)
thrownewNoSuchElementException();
Object[] elementData =ArrayList.this.elementData;
if(i >= elementData.length)
thrownewConcurrentModificationException();
cursor = i;//修改遊標，下一個元素仍是當前返回的previous元素
return(E) elementData[lastRet = i];
}
//設置當前元素（lastRet指向的值）的值爲e
publicvoidset(E e){
if(lastRet <0)
thrownewIllegalStateException();
checkForComodification();
try{
ArrayList.this.set(lastRet, e);
}catch(IndexOutOfBoundsException ex){
thrownewConcurrentModificationException();
}
}
//在下一個遊標處添加一個元素（remove的時候，遊標回到移除的元素位置）
publicvoid add(E e){
checkForComodification();
try{
int i = cursor;
ArrayList.this.add(i, e);
cursor = i +1;
lastRet =-1;
expectedModCount = modCount;
}catch(IndexOutOfBoundsException ex){
thrownewConcurrentModificationException();
}
}
}
/**
* 返回一個子列表，子列表的範圍爲列表[fromIndex,toIndex)之間的元素，不包括同Index
* 若是fromIndex和同Index相同，則返回空列表
* 不建立新的List，在SubList中持有一個當前ArrayList實例的引用，以及子列表的索引範圍
* 子列表的語義將變得不明確若是當前ArrayList實例結構發生變化（增刪、擴容）
* @throws IndexOutOfBoundsException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
*/
publicList<E> subList(int fromIndex,int toIndex){
subListRangeCheck(fromIndex, toIndex, size);
returnnewSubList(this,0, fromIndex, toIndex);
}
//檢查子列表範圍是否正確
staticvoid subListRangeCheck(int fromIndex,int toIndex,int size){
if(fromIndex <0)
thrownewIndexOutOfBoundsException("fromIndex = "+ fromIndex);
if(toIndex > size)
thrownewIndexOutOfBoundsException("toIndex = "+ toIndex);
if(fromIndex > toIndex)
thrownewIllegalArgumentException("fromIndex("+ fromIndex +
") > toIndex("+ toIndex +")");
}
/*Sublist-Start*/
//定義子列表類，維持一個得到子列表的ArrayList實例以及偏移量
//子列表偏移量和列表大小
privateclassSubListextendsAbstractList<E>implementsRandomAccess{
privatefinalAbstractList<E> parent;
privatefinalint parentOffset;
privatefinalint offset;
int size;
//構造方法，傳入父列表，子列表偏移量，開始的索引和結束的索引
SubList(AbstractList<E> parent,
int offset,int fromIndex,int toIndex){
this.parent = parent;
this.parentOffset = fromIndex;
this.offset = offset + fromIndex;
this.size = toIndex - fromIndex;
this.modCount =ArrayList.this.modCount;
}
//設置index處的值爲e，直接操做父列表，須要檢查範圍
public E set(int index, E e){
rangeCheck(index);
checkForComodification();
E oldValue =ArrayList.this.elementData(offset + index);
ArrayList.this.elementData[offset + index]= e;
return oldValue;
}
//獲取index處的值，須要檢查範圍，並檢查是否有修改
public E get(int index){
rangeCheck(index);
checkForComodification();
returnArrayList.this.elementData(offset + index);
}
//得到子列表的大小，檢查是否有修改
publicint size(){
checkForComodification();
returnthis.size;
}
//在index處添加一個元素e，須要檢查範圍和是否有修改
publicvoid add(int index, E e){
rangeCheckForAdd(index);
checkForComodification();
parent.add(parentOffset + index, e);
this.modCount = parent.modCount;
this.size++;
}
//移除index處的元素，並返回刪除的元素
public E remove(int index){
rangeCheck(index);
checkForComodification();
E result = parent.remove(parentOffset + index);
this.modCount = parent.modCount;
this.size--;
return result;
}
//移除[fromIndex,toIndex)之間的元素，檢查是否有修改列表結構
protectedvoid removeRange(int fromIndex,int toIndex){
checkForComodification();
parent.removeRange(parentOffset + fromIndex,
parentOffset + toIndex);
this.modCount = parent.modCount;
this.size -= toIndex - fromIndex;
}
//在子列表末尾添加c中全部元素
publicboolean addAll(Collection<?extends E> c){
return addAll(this.size, c);
}
//在子列表index起添加c中全部元素，須要檢查範圍和是否有修改
publicboolean addAll(int index,Collection<?extends E> c){
rangeCheckForAdd(index);
int cSize = c.size();
if(cSize==0)
returnfalse;
checkForComodification();
parent.addAll(parentOffset + index, c);
this.modCount = parent.modCount;
this.size += cSize;
returntrue;
}
//得到迭代器
publicIterator<E> iterator(){
return listIterator();
}
//得到ListIterator迭代器（可向前、向後）
publicListIterator<E> listIterator(finalint index){
checkForComodification();
rangeCheckForAdd(index);
finalint offset =this.offset;
returnnewListIterator<E>(){
int cursor = index;
int lastRet =-1;
int expectedModCount =ArrayList.this.modCount;
publicboolean hasNext(){
return cursor !=SubList.this.size;
}
@SuppressWarnings("unchecked")
public E next(){
checkForComodification();
int i = cursor;
if(i >=SubList.this.size)
thrownewNoSuchElementException();
Object[] elementData =ArrayList.this.elementData;
if(offset + i >= elementData.length)
thrownewConcurrentModificationException();
cursor = i +1;
return(E) elementData[offset +(lastRet = i)];
}
publicboolean hasPrevious(){
return cursor !=0;
}
@SuppressWarnings("unchecked")
public E previous(){
checkForComodification();
int i = cursor -1;
if(i <0)
thrownewNoSuchElementException();
Object[] elementData =ArrayList.this.elementData;
if(offset + i >= elementData.length)
thrownewConcurrentModificationException();
cursor = i;
return(E) elementData[offset +(lastRet = i)];
}
//對未迭代的元素進行特定的操做，並將遊標移到迭代完成的位置
@SuppressWarnings("unchecked")
publicvoid forEachRemaining(Consumer<?super E> consumer){
Objects.requireNonNull(consumer);
finalint size =SubList.this.size;
int i = cursor;
if(i >= size){
return;
}
finalObject[] elementData =ArrayList.this.elementData;
if(offset + i >= elementData.length){
thrownewConcurrentModificationException();
}
while(i != size && modCount == expectedModCount){
consumer.accept((E) elementData[offset +(i++)]);
}
//更新遊標
lastRet = cursor = i;
checkForComodification();
}
publicint nextIndex(){
return cursor;
}
publicint previousIndex(){
return cursor -1;
}
publicvoid remove(){
if(lastRet <0)
thrownewIllegalStateException();
checkForComodification();
try{
SubList.this.remove(lastRet);
cursor = lastRet;
lastRet =-1;
expectedModCount =ArrayList.this.modCount;
}catch(IndexOutOfBoundsException ex){
thrownewConcurrentModificationException();
}
}
publicvoidset(E e){
if(lastRet <0)
thrownewIllegalStateException();
checkForComodification();
try{
ArrayList.this.set(offset + lastRet, e);
}catch(IndexOutOfBoundsException ex){
thrownewConcurrentModificationException();
}
}
publicvoid add(E e){
checkForComodification();
try{
int i = cursor;
SubList.this.add(i, e);
cursor = i +1;
lastRet =-1;
expectedModCount =ArrayList.this.modCount;
}catch(IndexOutOfBoundsException ex){
thrownewConcurrentModificationException();
}
}
finalvoid checkForComodification(){
if(expectedModCount !=ArrayList.this.modCount)
thrownewConcurrentModificationException();
}
};
}
//從當前子序列得到子序列，offset當前子列表位於最原始的列表的偏移
publicList<E> subList(int fromIndex,int toIndex){
subListRangeCheck(fromIndex, toIndex, size);
returnnewSubList(this, offset, fromIndex, toIndex);
}
//檢查當前索引的範圍是否正確
privatevoid rangeCheck(int index){
if(index <0|| index >=this.size)
thrownewIndexOutOfBoundsException(outOfBoundsMsg(index));
}
//檢查當前索引的範圍是否正確
privatevoid rangeCheckForAdd(int index){
if(index <0|| index >this.size)
thrownewIndexOutOfBoundsException(outOfBoundsMsg(index));
}
//生成索引越界錯誤消息
privateString outOfBoundsMsg(int index){
return"Index: "+index+", Size: "+this.size;
}
//判斷是否有修改
privatevoid checkForComodification(){
if(ArrayList.this.modCount !=this.modCount)
thrownewConcurrentModificationException();
}
publicSpliterator<E> spliterator(){
checkForComodification();
//子列表的已經不是第一次使用
//fence 爲父列表中屬於子列表的最後一個元素的索引
returnnewArrayListSpliterator<E>(ArrayList.this, offset,
offset +this.size,this.modCount);
}
}
/**
* 對數組中的元素執行特定的操做，不容許在此過程當中修改
*/
@Override
publicvoid forEach(Consumer<?super E> action){
Objects.requireNonNull(action);
finalint expectedModCount = modCount;
@SuppressWarnings("unchecked")
final E[] elementData =(E[])this.elementData;
finalint size =this.size;
for(int i=0; modCount == expectedModCount && i < size; i++){
action.accept(elementData[i]);
}
if(modCount != expectedModCount){
thrownewConcurrentModificationException();
}
}
/**
* 在列表上建立一個延遲綁定和fail-fast機制
*
* Spliterator提供列表的遍歷和元素分割
*
* @return a {@code Spliterator} over the elements in this list
* @since 1.8
*/
@Override
publicSpliterator<E> spliterator(){
returnnewArrayListSpliterator<>(this,0,-1,0);
}
/** Index-based split-by-two, lazily initialized Spliterator */
staticfinalclassArrayListSpliterator<E>implementsSpliterator<E>{
/*
* 實在看不懂 ==！
* 若是ArrayList是不可變或者結構上不可變的（adds，removs等），可使用
* Arrays.spliterator來實現。遍歷過程當中，不犧牲太多性能的狀況下，咱們能夠檢測到
* 干擾。（不太通，Instead we detect as much interference during traversal
* as practical without sacrificing much performance.）咱們主要依賴於
* modCounts。雖然這並不能保證檢查到併發訪問衝突，並且有時對於線程間的干擾過於保
* 守，可是發現足夠的問題在實踐中是值得的。爲了實現這個功能，作了如下幾點：
* 1. 延遲初始化fence和expectedModCount直到須要咱們提交咱們正在檢測的狀態信息
* 以此提升精確性(這不適用於子列表，子列表使用非延遲加載值）
* 2. 只在forEach結束時檢測一次ConcurrentModificationException異常（性能最
* 敏感的方法）。使用forEach（與迭代器相反），咱們一般只能在action操做以後檢測
* 干擾，而不是開始以前。由於干擾的緣由，假設如null或者列表元素很小，更進一步的
* CME-triggering檢測將應用於全部的可能破外。這容許forEach內部的循環在運行時不
* 進行進一步檢查，簡化lambda表達式的操做。雖然這確實須要大量的檢查（
* list.stream().forEach(a)相同的狀況）, 沒有其餘的檢測和計算髮生在forEach內，
* 其餘不常使用的方法不能從流中得到大部分性能
*/
privatefinalArrayList<E> list;
privateint index;// 當前的索引（advance/split操做的對象）
privateint fence;// -1 until used; then one past last index
privateint expectedModCount;// 當fence設置後初始化
/** 根據範圍建立一個Spliterator */
ArrayListSpliterator(ArrayList<E> list,int origin,int fence,
int expectedModCount){
this.list = list;// 能夠是null（除非須要遍歷）
this.index = origin;
this.fence = fence;
this.expectedModCount = expectedModCount;
}
privateint getFence(){// 第一次使用時，初始化fence爲size
int hi;// (a specialized variant appears in method forEach)
ArrayList<E> lst;
if((hi = fence)<0){//第一次使用，則初始化
if((lst = list)==null)
hi = fence =0;
else{
expectedModCount = lst.modCount;//初始化expectedModCount
hi = fence = lst.size;
}
}
return hi;
}
publicArrayListSpliterator<E> trySplit(){
//求中間索引，>>>無符號右移，高位補0
int hi = getFence(), lo = index, mid =(lo + hi)>>>1;
return(lo >= mid)?null:// 分紅兩份，若是列表過小返回null
newArrayListSpliterator<E>(list, lo, index = mid,
expectedModCount);
}
//執行特定操做，用於遍歷，每調用一次，index增大，知道fence（也即到列表末尾）
publicboolean tryAdvance(Consumer<?super E> action){
if(action ==null)
thrownewNullPointerException();
int hi = getFence(), i = index;
if(i < hi){
index = i +1;
@SuppressWarnings("unchecked") E e =(E)list.elementData[i];
action.accept(e);
if(list.modCount != expectedModCount)
thrownewConcurrentModificationException();
returntrue;
}
returnfalse;
}
//遍歷執行特定操做
publicvoid forEachRemaining(Consumer<?super E> action){
int i, hi, mc;// hoist accesses and checks from loop
ArrayList<E> lst;Object[] a;
if(action ==null)
thrownewNullPointerException();
if((lst = list)!=null&&(a = lst.elementData)!=null){
if((hi = fence)<0){
mc = lst.modCount;
hi = lst.size;
}
else
mc = expectedModCount;
if((i = index)>=0&&(index = hi)<= a.length){
for(; i < hi;++i){
@SuppressWarnings("unchecked") E e =(E) a[i];
action.accept(e);
}
if(lst.modCount == mc)
return;
}
}
thrownewConcurrentModificationException();
}
//得到還剩餘的未遍歷的元素數
publiclong estimateSize(){
return(long)(getFence()- index);
}
//Spliterator特徵
publicint characteristics(){
returnSpliterator.ORDERED |Spliterator.SIZED |Spliterator.SUBSIZED;
}
}
/**
* 根據條件移除元素，元素有移除，則返回true
*/
@Override
publicboolean 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;
finalBitSet removeSet =newBitSet(size);
finalint expectedModCount = modCount;
finalint 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);//設置第i位爲1，標記移除
removeCount++;//記錄移除的記錄數
}
}
//此過程當中發生列表結構修改，拋出異常
if(modCount != expectedModCount){
thrownewConcurrentModificationException();
}
// 將沒有移除的元素向前移動
finalboolean anyToRemove = removeCount >0;
if(anyToRemove){
finalint newSize = size - removeCount;
for(int i=0, j=0;(i < size)&&(j < newSize); i++, j++){
//找到i以後第一個爲false的index，也即未標記移除的
i = removeSet.nextClearBit(i);
elementData[j]= elementData[i];
}
for(int k=newSize; k < size; k++){
elementData[k]=null;//清除須要刪除的引用，以讓垃圾回收器回收
}
this.size = newSize;//更新尺寸
//此過程當中發生列表結構修改，拋出異常
if(modCount != expectedModCount){
thrownewConcurrentModificationException();
}
modCount++;
}
//移除元素，則返回true
return anyToRemove;
}
/**
* 對列表中每個元素根據傳入的UnaryOperator，執行特定操做，並用返回值替換原來的值
*/
@Override
@SuppressWarnings("unchecked")
publicvoid replaceAll(UnaryOperator<E>operator){
Objects.requireNonNull(operator);
finalint expectedModCount = modCount;
finalint size =this.size;
for(int i=0; modCount == expectedModCount && i < size; i++){
//執行特定操做，並用返回值替換原來的值
elementData[i]=operator.apply((E) elementData[i]);
}
if(modCount != expectedModCount){
thrownewConcurrentModificationException();
}
modCount++;
}
//根據傳入的比較器c對列表進行排序
@Override
@SuppressWarnings("unchecked")
publicvoid sort(Comparator<?super E> c){
finalint expectedModCount = modCount;
Arrays.sort((E[]) elementData,0, size, c);
//排序過程當中發生列表結構變化，則拋出異常
if(modCount != expectedModCount){
thrownewConcurrentModificationException();
}
modCount++;
}
}

ArrayList 中的很大部分操做，使用了Arrays.copyof()和System.arraycopy()進行數組的拷貝，須要進一步分析其源碼
列表的排序使用Arrays.sort()，進一步分析其源碼java

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。