Java容器深入研究(jdk 1.8)--- ArrayList總結與原始碼分析
結構:public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
繼承自 AbstractList<E> ,這是一個抽象類對一些基礎的list操作做了一些封裝,實現了RandomAccess 標記介面,表明可以實現快速隨機訪問,Cloneable介面的實現表示該容器具有Clone函式操作,Serializable是序列化。
內部儲存結構:
構造方法:transient Object[] elementData; //transient關鍵字修飾的一個Object陣列,為什麼會用到transient後面再解釋; 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); } } //構造一個預設的空ArrayList,這裡並沒有初始化,jdk 1.8之後是在進行add操作後初始化 public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } //構造一個具有指定元素的ArrayList 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; } }
增加操作:
擴容檢查:/** * 在陣列末尾加上一個元素 */ public boolean add(E e) { ensureCapacityInternal(size + 1); elementData[size++] = e; return true; } /** * 在某個位置加入一個元素element * @param index * @param element */ public void add(int index, E element) { //檢查index是否越界 rangeCheckForAdd(index); //進行擴容檢查 ensureCapacityInternal(size + 1); // Increments modCount!! //對資料進行復制操作,空出index位置,並插入element,後移index後面的元素 System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; }
/**
* 這個擴容方法,內部沒有呼叫,判斷ArrayList是否為空
* @param minCapacity
*/
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
? 0
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
/**
* 擴容檢查
* @param minCapacity
*/
private void ensureCapacityInternal(int minCapacity) {
//第一次add操作初始化,如果為空ArrayList,那麼初始化容量為10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//判斷是否需要擴容
ensureExplicitCapacity(minCapacity);
}
/**
* 判斷是否需要擴容
* @param minCapacity
*/
private void ensureExplicitCapacity(int minCapacity) {
//modCount這個引數運用到了 fail-fast 機制,後面解釋
modCount++;
//擴容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//最大容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 將整個陣列size擴容為1.5倍
*/
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//newCapacity為以前的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//判斷容量是否到達long int 最大臨界值
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 對陣列進行復制處理
elementData = Arrays.copyOf(elementData, newCapacity);
}
//檢查是否超過最大容量 0x7fffffff ,是否丟擲異常
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擴充自己的容量是,擴充為以前的1.5倍刪除元素:
/**
* 根據索引刪除元素
* @param index
* @return
*/
public E remove(int index) {
//陣列越界檢查
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
//計算陣列需要複製的數量
int numMoved = size - index - 1;
//將index後的資料都向前移一位
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//let GC
elementData[--size] = null;
return oldValue;
}
/**
* 根據元素內容匹配並刪除,只刪除第一個匹配成功的
* @param o
* @return
*/
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
}
陣列節約記憶體空間,縮小容量的方法 : trimToSize
/**
* 陣列縮小容量,增加元素會進行擴容,但刪除元素沒有縮容,
* 這個方法是用來提供縮小陣列容量
*/
public void trimToSize() {
modCount++;
//length是陣列長度,size表示陣列內元素個數
//size<length那麼就說明陣列內有空元素,進行縮小容量操作
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
現在ArrayList的增加和刪除,及擴容操作都明白了吧。為什麼ArrayList 不適合頻繁插入和刪除操作?就是因為在ArrayList中我們一直會呼叫 System.arraycopy 這個效率很低的操作來複制陣列,所以導致ArrayList在插入和刪除操作中效率不高。
在ArrayList中,還提供了 Iterator 和 ListIterator 這兩種迭代器,他們有什麼區別呢?
ListIterator 與普通的 Iterator相比,它增加了增、刪、設定元素、向前向後遍歷的操作。
在結構上面 :public interface ListIterator<E> extends Iterator<E> ,我們看看他們的結構圖就會一目瞭然了。
關於ModCount :
我們先說說 容器的“快速失敗”機制,它是Java集合中的一種錯誤檢測機制,當多個執行緒對集合進行結構上的改變的操作時,有可能會產生fail-fast機制。它是一種迭代器檢測bug的機制,比如:我們有執行緒A和執行緒B,執行緒A通過Iterator訪問集合中的元素,某個時刻,執行緒B修改了集合中的結構,那麼程式就會丟擲 ConcurrentModificationException 。
這個fail-fast機制是怎麼實現的呢?
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
沒錯,在迭代器中的 add 、remove 、 next等方法中都呼叫了此方法,判斷 modCount 和 expectedModCount是否相等,來決定是否丟擲異常。
在迭代器中,int expectedModCount = modCount; 中定義了 expectedModCount , 這個值是不會變化的,所以使用迭代器遍歷整個ArrayList時,我們只需要判斷是否進行了那些會讓 ModCount 改變的方法,從而知道了集合是否發生了結構上的變化。註明:在LruCahe當中,因為它的底層是一個 HashLinkedMap 實現,使用了最近最少使用演算法,所以迭代器在使用 get 方法的時候,也會丟擲這個異常,所以謹慎使用。
還有一個問題,為什麼底層陣列會有 transient 關鍵字修飾?貌似 HashMap底層也是這個關鍵字修飾的 :transient Node<K,V>[] table ?
我會單獨寫一篇部落格來解釋,transient關鍵字的作用,還有關於 Iterator迭代器模式。
有什麼不好的地方還望指正~~~