Java集合原始碼分析03----ArrayList原始碼分析
阿新 • • 發佈：2018-11-06
目錄
簡介
ArrayList位置java.util包下面，是List集合的一種，底層是動態陣列，它的容量能夠動態的增長。ArrayList是非同步的，只能在單執行緒中使用。
ArrayList繼承AbstractList抽象類，並且實現List介面，提供了操作元素的方法；實現了RandomAccess介面，支援快速隨機訪問，通過索引可以訪問元素；實現了Cloneable介面，能被克隆；實現了java.io.Serializable介面，支援序列化，並能進行序列化傳輸。
ArrayList擅長訪問元素，但是插入和移除元素比較慢。
ArrayList介紹（基於jdk1.8）
1.構造方法
public ArrayList(Collection<? extends E> c){}
public ArrayList() {}
public ArrayList(int initialCapacity){}- 構建一個包含了集合c的元素的ArrayList。
- 無參建構函式，構建一個容量為10的ArrayList(官方解釋)，在jdk1.8中預設是空例項，在呼叫add()/addAll()方法時會進行擴容。
- 構造一個指定容量大小的ArrayList。
2.內部變數
private static final int DEFAULT_CAPACITY = 10; private static final Object[] EMPTY_ELEMENTDATA = {}; private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; transient Object[] elementData; private int size;
- DEFAULT_CAPACITY----預設的容器大小。
- DEFAULTCAPACITY_EMPTY_ELEMENTDATA與EMPTY_ELEMENTDATA相比，在新增第一個元素後確定擴容多大。
- elementData----ArrayList的底層陣列緩衝。
- size----ArrayList中元素的總數。
3.內部方法
public void trimToSize(){} public void ensureCapacity(int minCapacity) {} public int size() {} public boolean isEmpty() {} public boolean contains(Object o) {} public int indexOf(Object o) {} public int lastIndexOf(Object o) {} public Object clone() {} public Object[] toArray() {} public <T> T[] toArray(T[] a) {} public E get(int index) {} public E set(int index, E element) {} public boolean add(E e) {} public void add(int index, E element) {} public E remove(int index) {} public boolean remove(Object o) {} public void clear() {} public boolean addAll(Collection<? extends E> c) {} public boolean addAll(int index, Collection<? extends E> c) {} public boolean removeAll(Collection<?> c) {} public boolean retainAll(Collection<?> c) {} public ListIterator<E> listIterator(int index) {} public ListIterator<E> listIterator() {} public Iterator<E> iterator() {} public List<E> subList(int fromIndex, int toIndex) {} public void forEach(Consumer<? super E> action) {} public Spliterator<E> spliterator() {} public boolean removeIf(Predicate<? super E> filter) {} public void replaceAll(UnaryOperator<E> operator) {} public void sort(Comparator<? super E> c) {}
- trimToSize()----將ArrayList的實際容量調整為實際元素總數大小。
- ensureCapacity()----如有必要，ArrayList需要擴容，以容納minCapacity個元素個數。
- size()---返回ArrayList中元素總數。
- isEmpty()----如果ArrayList中沒有任何元素，則返回true。
- contains(Object o)----如果ArrayList中包含指定的元素o，返回true。
- indexOf(Object o)----返回ArrayList中首次出現指定元素的索引，如果不包含指定元素，返回-1。
- lastIndexOf(Object o)----返回ArrayList中最後出現指定元素的索引，如果不包含指定元素，返回-1。
- clone()----返回ArrayList例項的淺度複製。
- toArray()----按合適的順序（第一個到最後一個元素）返回包含ArrayList中所有元素的陣列。
- toArray(T[] a)----按合適的順序（第一個到最後一個元素）返回包含ArrayList中所有元素的陣列，返回陣列的執行型別是指定的陣列型別。
- get(int index)----獲取ArrayList中指定索引位置的元素。
- set(int index,E element)----用指定的元素替換ArrayList指定索引的元素。
- add(E e)----將指定的元素新增到ArrayList的尾部。
- add(int index, E element)----將指定元素新增到ArrayList指定的元素。
- remove(int index)----移除ArrayList中指定索引的元素。
- remove(Object o )----移除ArrayList中首次出現的指定元素。
- clear()---清空ArrayList中所有元素。
- add(Collection<? extends E> c)----將集合c中的所有元素新增到ArrayList中。
- addAll(int index, Collection<? extends E> c)----將集合c中所有元素新增到ArrayList中，位置從index開始。
- removeAll(Collection<?> c)----從ArrayList中移除包含在集合c中的所有元素。
- retainAll(Collection<?> c)----包留ArrayList中包含在集合c中的元素，即請求ArrayList和集合c的交集。
- listIterator(int index)----返回ArrayList中指定位置開始的所有元素的迭代器。
- listIterator()----返回ArrayList中所有元素的迭代器ListIterator。
- iterator()----返回ArrayList中所有元素的迭代器Iterator。
- subList(int fromIndex, int toIndex)----返回ArrayList中fromIndex開始（包含）到toIndex（不包含）之間所有元素。
- forEach(Consumer<? super E> action)----jdk1.8,對ArrayList中所有元素執行指定action操作。
- removeIf(Predicate<? super E> filter)-----jdk1.8,用於移除符合指定條件的元素。
- replaceAll(UnaryOperator<E> operator)----對每個元素執行operator指定的操作，並用操作結果來替換原來的元素。
- sort(Comparator<? super E> c)----將ArrayList中所元素按照指定規則進行排序。
原始碼分析
關於原始碼的幾點說明：
1）ArrayList底層是陣列緩衝elementData，向ArrayList新增元素會判斷是否需要擴容，elementData被transient關鍵字修飾，無法序列化（被static修飾的欄位也無法序列化），ArrayList序列化是將元素長度和所有元素寫到流中。
2）modCount在原始碼中多次出現，用來記錄修改次數，由於ArrayList是非執行緒安全的，任何對ArrayList的修改都會增加。迭代器迭代初始化時會賦值給 expectedModCount。在迭代過程中，會判斷 modCount是否等於 expectedModCount，如果不等，說明其他執行緒修改了ArrayList，就會丟擲ConcurrentModificationException異常。
3）最大擴容到Integer.MAX_VALUE - 8是由於預留出位置用於儲存陣列元資訊（指標指向類資訊，描述物件型別）。
4）注意elementData.length與size的區別，elementData是底層陣列的容量大小，size是陣列中元素的總數。
5）類似操作subList（fromIndex,toIndex）,包含了索引fromIndex,其範圍是0-（size-1）,而toIndex是不包含，其範圍是0-size。
所以toIndex>=fromIndex，當toIndex==fromIndex時，表示不做任何的操作。
6）elementData[--size]，陣列的下標是0開始，所以最後一個元素索引是size-1,--size操作表示size本身自減1，然後再使用size。
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 = {};
//elementData是ArrayList儲存元素的陣列緩衝，ArrayList的容量是陣列緩衝長度，
//任何elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList會在新增第一個元素後擴容到DEFAULT_CAPACITY=10。
//由於被transient修飾，無法序列化（被static修改的欄位也無法序列化）
transient Object[] elementData; // non-private to simplify nested class access
//ArrayList的大小（即包含元素的數量）
private int size;
//構造一個指定初始容量的ArrayList
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);
}
}
//構造一個初始容量為10的空ArrayList(官方解釋)，實際會在新增第一個元素後會才進行擴容
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//構造一個包含了指定collection的元素的ArrayList,與collection的迭代器返回的順序是一樣的
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
//縮減ArrayList的容量到當前實際元素總數大小
public void trimToSize() {
//modCount用來記錄修改次數，由於ArrayList是非執行緒安全的，任何對ArrayList的修改都會增加modCount的值，
//迭代器迭代初始化時會賦值給 expectedModCount。在迭代過程中，會判斷 modCount是否等於 expectedModCount，
//如果不等，說明其他執行緒修改了ArrayList，就會丟擲ConcurrentModificationException異常
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
//擴充ArrayList的容量，如有必要保證其容量至少能儲存指定的minCapacity個元素
public void ensureCapacity(int minCapacity) {
//這裡判斷是ArrayList容量是否是預設的，如果是不是預設的需要擴容
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, int minCapacity) {
//DEFAULTCAPACITY_EMPTY_ELEMENTDATA是無參建構函式建立的，初次新增元素會擴容到預設大小（10）
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
//如果有引數建構函式，在原先的容量上擴容minCapacity
return minCapacity;
}
//在add()/addAll()方法呼叫的時候，進行擴容
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//預留出位置用於儲存陣列的元資訊（指標指向類資訊，描述物件型別）
//https://stackoverflow.com/questions/35756277/why-the-maximum-array-size-of-arraylist-is-integer-max-value-8
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//oldCapacity右移1位，即oldCapacity/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:
//複製陣列，容量為newCapacity
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
//返回ArrayList中的元素個數
public int size() {
return size;
}
//如果ArrayList中不包含任何元素，返回true.
public boolean isEmpty() {
return size == 0;
}
//如果ArrayList中包含指定的元素，返回true
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
//返回ArrayList中首次出現指定元素的索引，如果不包含元素，返回-1.
public int indexOf(Object o) {
if (o == null) {
//如果為null的時候，遍歷陣列，找到第一個null對應的索引
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
//如果不為null的情況下，遍歷陣列，找到符合要求的第一個元素對應索引
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
//找不到對應的元素，返回-1
return -1;
}
//返回ArrayList中最後出現指定元素的索引，如果不包含元素，返回-1
public int lastIndexOf(Object o) {
if (o == null) {
//如果為null，逆向遍歷，找到第一個null，返回對應索引
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
//如果不為null的情況下，逆向遍歷，找到符合要求的第一個元素對應索引
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
//找不到對應的元素，返回-1
return -1;
}
//返回ArrayList例項的淺度複製
public Object 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
throw new InternalError(e);
}
}
//按適當的順序返回（從第一個到最後一個元素）包含ArrayList中所有元素的陣列
public Object[] toArray() {
//陣列的大小是size,而不是length
return Arrays.copyOf(elementData, size);
}
//按適當的順序返回（從第一個到最後一個元素）包含ArrayList中所有元素的陣列
//並且返回陣列的執行型別是指定的陣列型別
public <T> T[] toArray(T[] a) {
//會判斷a的長度與集合當前size
//a的長度小於size時，複製elementData副本，轉換對應型別
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
//a的長度大於等於size時，將elementDate元素直接複製到a中
System.arraycopy(elementData, 0, a, 0, size);
//將陣列中大於size位置置為null
if (a.length > size)
a[size] = null;
return a;
}
// Positional Access Operations
//返回陣列中指定索引位置上的元素
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
//返回ArrayList中指定索引的元素
public E get(int index) {
//檢查索引index範圍
rangeCheck(index);
return elementData(index);
}
//用指定的元素替換ArrayList中指定索引的元素
public E set(int index, E element) {
//檢查索引index範圍
rangeCheck(index);
//根據索引獲取原先值
E oldValue = elementData(index);
//用element替換原先位置上的值
elementData[index] = element;
return oldValue;
}
//將指定的元素新增到ArrayList的尾部
public boolean add(E e) {
//擴容
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
//將指定的元素新增到ArrayList指定的位置
public void add(int index, E element) {
//檢查索引的範圍
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
//將index索引後整體向後移動一個位置
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
//移除ArrayList中指定位置的元素
public E remove(int index) {
//檢查索引的位置
rangeCheck(index);
modCount++;
//獲取指定索引位置的值
E oldValue = elementData(index);
//刪除index位置,需要將index+1----size之間的元素整體前移一個位置
//所以總共移動的元素個數=size-(index+1)=numMoved
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//ArrayList中總元素數是size，索引從0開始，最後一個元素的索引是size-1
//--size同時實現size的自減
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
//移除ArrayList中首次出現的指定元素
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;
}
/*
* Private remove method that skips bounds checking and does not
* return the value removed.
*/
private void fastRemove(int index) {
modCount++;
//需要移除的元素索引是index,需要將index+1----size之間位置元素整體前移
//需要移動的元素總數是size-(index+1);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//ArrayList中總元素數是size，索引從0開始，最後一個元素的索引是size-1
elementData[--size] = null; // clear to let GC do its work
}
//從ArrayList中移除所有的元素
public void clear() {
modCount++;
// clear to let GC do its work
//遍歷集合，將所有索引位置置為null
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
//將集合c中元素新增到ArrayList的末尾，按照c迭代器返回的順序。
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
//擴容
ensureCapacityInternal(size + numNew); // Increments modCount
//將集合c中元素複製到elementData的末尾，長度是集合c的長度
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
//將集合c中所有元素新增到ArrayList中，位置從指定的index開始。
public boolean addAll(int index, Collection<? extends E> c) {
//檢查索引的範圍
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
//擴容
ensureCapacityInternal(size + numNew); // Increments modCount
//計算列表中index開始元素個數
int numMoved = size - index;
if (numMoved > 0)
//將ArrayList中index開始的元素總數向後移動numNew個位置，為了向list中新增集合c所有元素
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
//移除ArrayList中從fromIndex索引(包含)開始到toIndex(不包含)之間的所有元素
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
//list中從toIndex索引開始的元素整體移動到fromIndex索引開始，個數toIndex之後的元素總數
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// clear to let GC do its work
//list之前元素總數減去刪除元素總數
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
//將多出的位置置為null
elementData[i] = null;
}
size = newSize;
}
//檢查索引範圍，超出size，索引越界
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//用於add和addAll的方法的檢查索引的方法
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;
}
//從ArrayList中移除所有包含在指定集合c中的元素
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
//ArrayList中只保留指定集合c中包含的元素，即移除ArrayList中不包含了指定集合c中元素
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}
//批量刪除
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
//當complement=true時，elementData中所有包含在集合c中的元素被保留
//當complement=false時，elementData中所有不包含在集合c中的元素被保留
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.
//按道理for迴圈中最後r++肯定會等於size,r!=size表示可能發生異常
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
//w是保留元素最後一個索引值，for迴圈中最後會進行w++操作，如果size==w,表明所有元素保留，返回false
//w！=size表明w後面索引位置現在沒有元素，但之前的elementData中w後面位置後元素存在，需要將這些位置置為null
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;
}
}
return modified;
}
//將arrayList中容量以及所元素寫到流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.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<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
//重新構建ArrayList例項，先讀取陣列的容量，在讀取所有的元素
private void readObject(java.io.ObjectInputStream s)
throws java.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<size; i++) {
a[i] = s.readObject();
}
}
}
//返回ArrayList中指定位置開始所有元素的迭代器
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
//返回ArrayList所有元素的迭代器(以合適的順序)
public ListIterator<E> listIterator() {
return new ListItr(0);
}
//返回ArrayList中所有元素的迭代器(以合適的順序)
public Iterator<E> iterator() {
return new Itr();
}
//內部類，迭代集合的迭代器
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
Itr() {}
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向前移動
cursor = i + 1;
//返回elementData中索引為i的元素
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
//檢查是否併發
checkForComodification();
try {
//呼叫ArrayList中remove()方法移除元素
//lastRet在next()中進行賦值為i
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
//迴圈陣列
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++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
//檢查是否有併發修改的情況
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
//內部類，專門用於list集合遍歷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();
//i為遊標向前移動一位
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();
}
}
}
//返回ArrayList中索引fromIndex(包含)到toIndex(不包含)之間的所有的元素(部分檢視)
public List<E> subList(int fromIndex, int toIndex) {
//檢查索引的範圍
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
//對ArrayList中的所有元素執行的指定的action操作
public 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 new ConcurrentModificationException();
}
}
@Override
//移除符合指定條件filter的元素
public 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 = new BitSet(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 new ConcurrentModificationException();
}
// 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後面，第一個為false的索引
i = removeSet.nextClearBit(i);
elementData[j] = elementData[i];
}
//總共移除元素removeCount，需要將size-removeCout之後索引位置置為null
for (int k=newSize; k < size; k++) {
elementData[k] = null; // Let gc do its work
}
this.size = newSize;
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}
return anyToRemove;
}
//將ArrayList進行排序，會呼叫Arrays.sort()方法
public void sort(Comparator<? super E> c) {
final int expectedModCount = modCount;
Arrays.sort((E[]) elementData, 0, size, c);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}
}案例
public void test11() {
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
list.add(6);
System.out.println(list);
//迭代器遍歷元素
ListIterator<Integer> iter = list.listIterator();
while(iter.hasNext()) {
System.out.print(iter.next()+",");
}
System.out.println();
//對於list中所有元素執行後面的操作
list.forEach(li->System.out.print(li+","));
System.out.println();
//移除符合條件的元素
list.removeIf(li->li.intValue()%2==1);
System.out.println(list);
//sort()方法，升序
list.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
if(o1>o2) {
return 1;
}else if(o1<o2) {
return -1;
}else {
return 0;
}
}
});
System.out.println(list);
//sort()方法，降序
list.sort((x,y)->Integer.compare(y, x));
System.out.println(list);
}