知其然知其所以然之ArrayList常用原始碼閱讀

Mr_初晨發表於2018-07-27
原始碼
Hello大家好，本章我們簡單瞭解一下ArrayList 。有問題可以聯絡我mr_beany@163.com。另求各路大神指點，感謝

一：ArrayList簡介

ArrayList是基於陣列實現的，是一個動態陣列，其容量能自動增長； 由於ArrayList不是執行緒安全的，所以只能在單執行緒下使用；

二：ArrayList使用場景

由於ArrayList是基於陣列實現的，所以它有著陣列的特性，即能都給儲存進來的元素自動進行編號（下角標）。所以我們可以很方便的通過每個元素的編號來獲取該元素

三：提出問題

陣列的長度是不可變的，既然ArrayList是基於陣列實現，為什麼ArrayList可以新增，刪除元素？

四：走進原始碼

4.1：ArrayList的繼承關係

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable複製程式碼

ArrayList實現了Serializable介面，因此它支援序列化； 實現了RandomAccess介面，支援快速隨機訪問，實際上就是通過下標序號進行快速訪問； 實現了Cloneable介面，能被克隆。

4.2：ArrayList中的一些常量

   /**
     * 序列版本號 
     */
	private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 預設的陣列大小
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 定義空陣列時使用，即當初始化陣列大小為0的時候使用
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 初始化沒有設定大小的時候使用。
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 儲存資料的陣列
     */
    transient Object[] elementData; 

    /**
     * ArrayList中實際資料的數量
     */
    private int size;複製程式碼

4.3：ArrayList的三個構造方法

/**
 * 當我們使用無參的構造方法時，會建立一個長度為0的陣列
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * ArrayList帶容量大小的建構函式。
 * 可以看到當initialCapacity==0 的時候使用的是EMPTY_ELEMENTDATA
 */
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(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
	//返回若不是Object[]則呼叫Arrays.copyOf方法將其轉為Object[]
	if (elementData.getClass() != Object[].class)
	    elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        this.elementData = EMPTY_ELEMENTDATA;
    }
}
複製程式碼

4.4：常用方法

 這個方法就是把縮小elementData大小，去掉多餘的陣列空間
 應用程式使用該操作降低ArrayList例項佔用的儲存
 因為清空等一些操作只改變引數而沒有釋放空間
public void trimToSize() {
	modCount++;
	if (size < elementData.length) {
		elementData = (size == 0)
		  ? EMPTY_ELEMENTDATA
		  : Arrays.copyOf(elementData, size);
	}
}


函式返回集合中給定元素的第一次出現的位置，如果沒有就返回-1
首先檢查o是否為null，如果為null，就返回集合中第一個null元素的位置；如果不為null，就是用equals函式進行相等性檢查。
之所以這樣，是因為如果直接對null呼叫equals方法，會丟擲空指標異常。
同時也不能迴圈遍歷陣列中的元素呼叫equals方法檢查是否相等，因為ArrayList集合中允許有null元素的存在。
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;
}


判斷集合中是否包含某個元素
public boolean contains(Object o) {
	return indexOf(o) >= 0;
}


函式返回給定元素最後一次出現的位置，如果沒有就返回-1：
原理和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;
}


檢查陣列下標越界
private void rangeCheck(int index) {
	if (index >= size)
		throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}


@SuppressWarnings("unchecked")
E elementData(int index) {
	return (E) elementData[index];
}



對於get方法來說，首先呼叫rangeCheck檢查下標，然後呼叫elementData返回元素：
public E get(int index) {
	rangeCheck(index);

	return elementData(index);
}



設定給定位置的元素為給定的元素，然後返回原來的元素   同樣，函式也先進行下標檢查。
public E set(int index, E element) {
	rangeCheck(index);

	E oldValue = elementData(index);
	elementData[index] = element;
	return oldValue;
}


重點!!add方法   這也是之前提出的疑問的地方
public boolean add(E e) {
	ensureCapacityInternal(size + 1);
	elementData[size++] = e;
	return true;
}

接下來我們看ensureCapacityInternal()
private void ensureCapacityInternal(int minCapacity) {
	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
	//如果初始化時沒有設定預設容量
	if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
		//返回預設容量(10) 和 指定容量  中最大值
		return Math.max(DEFAULT_CAPACITY, minCapacity);
	}
	否則返回當前長度+1
	return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
	modCount++;   //定義於ArrayList的父類AbstractList，用於儲存結構修改次數

	//如果指定的最小容量要超過了容器本來的長度，則需要擴容
	if (minCapacity - elementData.length > 0)
		grow(minCapacity);
}


private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//擴容方法
private void grow(int minCapacity) {
	//原始容量
	int oldCapacity = elementData.length;
	//新容量擴大到原容量的1.5倍，(其中>>是‘位運算子’)右移一位相關於原數值除以2。
	int newCapacity = oldCapacity + (oldCapacity >> 1);
	//如果計算出來的容量小了就將指定容量賦值給它
	if (newCapacity - minCapacity < 0)
		newCapacity = minCapacity;
	if (newCapacity - MAX_ARRAY_SIZE > 0)
		newCapacity = hugeCapacity(minCapacity);
	//使用新的長度進行復制，返回複製後的陣列
	//這裡我們可以看到所謂的動態陣列其實是重新建立了一個陣列，並不是改變了陣列的容量
	elementData = Arrays.copyOf(elementData, newCapacity);
}

//這裡之所以設定長度為Integer.MAX_VALUE - 8  是避免一些機器記憶體溢位，減少出錯機率  但是最大還是能支援到Integer.MAX_VALUE 
private static int hugeCapacity(int minCapacity) {
	if (minCapacity < 0) // overflow
		throw new OutOfMemoryError();
	return (minCapacity > MAX_ARRAY_SIZE) ?
		Integer.MAX_VALUE :
		MAX_ARRAY_SIZE;
}


刪除方法
public E remove(int index) {
	rangeCheck(index);

	modCount++;
	//將後面的列表物件前移
	E oldValue = elementData(index);

	int numMoved = size - index - 1;
	if (numMoved > 0)
		// 陣列前移一位，size自減，空出來的位置置null
		System.arraycopy(elementData, index+1, elementData, index,
						 numMoved);
	elementData[--size] = null; // clear to let GC do its work

	return oldValue;
}



帶有native標誌的為java呼叫系統的C/C++程式碼，該函式實際上最終呼叫了C語言的memmove()函式，因此它可以保證同一個陣列內元素的正確複製和移動，比一般的複製方法的實現效率要高很多，很適合用來批量處理陣列。Java強烈推薦在複製大量陣列元素時用該方法，以取得更高的效率。
public static native void arraycopy(Object src,  int  srcPos,
	Object dest, int destPos,
	int length);



複製程式碼

五：總結

ArrayList是由陣列實現的，可以通過下標索引直接查詢到指定位置的元素，因此查詢效率高；其可以新增元素的原理是每次新增都會重新建立物件，拷貝原資料，頻繁的新增刪除操作會消耗大量記憶體，所以ArrayList適用的場景為查詢元素


相關文章