ArrayList
list是java集合中很重要的一部分，而ArrayList是最常用的list，學習一下原始碼還是很有必要的。（以下程式碼來自jdk1.8.0_20）
繼承結構
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
複製程式碼ArrayList繼承自AbstractList，實現了List，RandomAccess，Cloneable，java.io.Serializable介面，RandomAccess介面表示ArrayList可以隨機訪問，因為ArrayList底層是陣列實現的。
成員變數
- 預設初始容量10
private static final int DEFAULT_CAPACITY = 10;
- 空陣列，初始化引數為0時使用
private static final Object[] EMPTY_ELEMENTDATA = {};
- 空陣列，預設初始化時使用，區別於EMPTY_ELEMENTDATA，第一次增加元素時擴容的大小不同
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
- 儲存元素的陣列
transient Object[] elementData;
建構函式
ArrayList有3個建構函式，包括無參建構函式，引數為int型的建構函式，引數為集合的建構函式。
引數為0時，elementData = EMPTY_ELEMENTDATA。第一次增加元素時擴容到1。
無參時，elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; 第一次增加元素時擴容為預設容量10。
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;
}
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;
}
}
複製程式碼主要方法
- add方法新增元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 新增元素時首先保證容量大小，並且modCount++
elementData[size++] = e; //容量大小足夠，對陣列size位置賦值，size加1
return true;
}
複製程式碼private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //無參宣告時，最小容量為預設大小10
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++; //修改次數加1
// overflow-conscious code
if (minCapacity - elementData.length > 0) //如果需要的最小容量大於當前陣列大小，進行擴容
grow(minCapacity);
}
複製程式碼private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1); //新容量大小為舊容量+舊容量/2
if (newCapacity - minCapacity < 0) //如果擴容1.5倍小於需要的最小容量，則使用最小容量，
例如new ArrayList(0)時，舊容量為0，1.5倍仍為0，而minCapacity為1
newCapacity = 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); //使用Arrays類的copyOf方法複製陣列
}
複製程式碼- set方法，設定下標index上的值，返回該下標上舊的元素值
public E set(int index, E element) {
rangeCheck(index); //下標範圍檢查
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
複製程式碼- get方法獲取元素
public E get(int index) {
rangeCheck(index); //首先進行下標檢查
return elementData(index); //返回陣列中的值
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
E elementData(int index) {
return (E) elementData[index];
}
複製程式碼-
remove方法
- remove(int index)（刪除下標index上的元素）
System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)，集合拷貝函式，五個引數分別表示：src源物件，srcPos源物件拷貝的起始下標，dest目標物件，destPos複製到目標物件的起始位置，length拷貝的長度
public E remove(int index) {
rangeCheck(index); //首先進行下標範圍檢查
modCount++; //修改次數加1
E oldValue = elementData(index);
int numMoved = size - index - 1; //計算需要移動的元素數量（刪除index上的資料之後，後面的資料需要前移1位）
if (numMoved > 0) //如果刪除的元素後有元素需要移動，呼叫System.arraycopy方法把後面的元素前移1位
System.arraycopy(elementData, index+1, elementData, index,
numMoved); //
elementData[--size] = null; // 最後一位賦值為null，方便垃圾回收
return oldValue;
}
複製程式碼-
- remove(Object o)（刪除第一個匹配的元素）
按元素刪除時，null分開判斷，因為null的equals結果總是返回false
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])) { //刪除非null的元素用equals判斷元素相等
fastRemove(index);
return true; //刪除第一個匹配的元素之後推出迴圈，不再查詢
}
}
return false;
}
//fastRemove(int index)方法和remove(int index)方法類似，只是不需要進行下標範圍檢查和返回刪除的元素值
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
}
複製程式碼- size方法，獲取元素數量
public int size() {
return size;
}
複製程式碼- isEmpty判空方法，直接判斷size的值是否為0
public boolean isEmpty() {
return size == 0;
}
複製程式碼- clear方法，清空陣列中元素
public void clear() {
modCount++;
for (int i = 0; i < size; i++)
elementData[i] = null; //把陣列中元素全部賦值為null方便垃圾回收，釋放空間
size = 0;
}
複製程式碼- indexOf方法，返回第一次匹配到的元素下標，沒有匹配到則返回-1
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;
}
複製程式碼- lastIndexOf方法，返回最後匹配到的元素下標，和indexOf方法類似，只是遍歷陣列時從後往前查詢
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;
}
複製程式碼- toArray方法，把列表轉化為陣列，實際上呼叫的是Arrays.copyOf(T[] original, int newLength)方法，而Arrays的兩個引數的copyOf方法呼叫的自己的三個引數的copyOf方法，只是第三個引數預設為源陣列的型別，ArrayList中的陣列型別是Object[]，所以返回的陣列型別也是Object[]型別。
這就是我們定義了ArrayList list=new ArrayList<>();然後獲取陣列時使用String[] array= (String[]) list.toArray();會丟擲Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;異常的原因。
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
複製程式碼Arrays.copyOf(T[] original, int newLength)方法
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
複製程式碼Arrays.copyOf(T[] original, int newLength, Class<? extends Object[]> newType)方法
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
複製程式碼ArrayList還有一個toArray方法，需要傳入一個陣列引數，從而避免上面這中類轉換異常。
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;
}
複製程式碼- sort方法（jdk1.8中新增），對列表中的元素進行排序，呼叫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++;
}
複製程式碼SubList
- subList方法，獲取子list
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size); //下標範圍檢查
return new SubList(this, 0, fromIndex, toIndex); //返回一個SubList物件
}
static void subListRangeCheck(int fromIndex, int toIndex, int size) {
if (fromIndex < 0)
throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
if (toIndex > size)
throw new IndexOutOfBoundsException("toIndex = " + toIndex);
if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex + ")");
}
複製程式碼SubList是ArrayList的一個內部類，構造如下，可以看出來SubList中並沒有儲存元素的陣列，而是使用成員變數記錄父列表中下標，所以修改父列表中的元素，子列表中的元素也會變化。SubList也有add、set、get、size等方法，方法體和ArrayList中的方法基本一樣或者是呼叫ArrayList中的方法。
private class SubList extends AbstractList<E> implements RandomAccess {
private final AbstractList<E> parent; //父列表
private final int parentOffset; //父列表中的偏移量
private final int 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;
}
add、set、get方法等。。。
}
複製程式碼Iterator迭代器
Iterator是用於遍歷集合類的標準訪問方法，它可以把訪問邏輯從不同型別的集合類中抽象出來，從而避免向客戶端暴露集合的內部結構。例如我們使用for迴圈來遍歷list，對於ArrayList和LinkedList我們就需要寫兩種不同的方法來訪問其中的元素，並且如果以後程式碼中的ArrayList換成LinkedList也需求修改大量使用到的程式碼。
我們首先使用list的iterator()方法獲取該列表的Iterator物件，然後使用Iterator物件的hasNext方法來判斷是否還有元素，next方法返回一個元素，remove方法刪除返回的元素。
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // 下一個返回元素的下標
int lastRet = -1; // 最後返回的元素的下標，如果是-1，代表沒有
int expectedModCount = modCount; //期望修改次數，用於fail-fast機制
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification(); //fail-fast機制檢查，如果有其他執行緒修改了這個list，會丟擲ConcurrentModificationException異常
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]; //返回元素，並記錄lastRet
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1; //remove方法執行過後，清除上次返回元素的記錄，不能再次呼叫該方法。
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++]);
}
// 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();
}
}
複製程式碼