重新認識java-ArrayList 頂 原

重新認識java-ArrayList

源碼解讀

ArrayList的聲明：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

通過繼承和實現關係，可以看出ArrayList繼承自抽象類AbstractList，實現了接口List, RandomAccess, Cloneable, java.io.Serializable.

RandomAccess接口

從RandomAccess的聲明中可以看到，這只是一個類聲明，沒有函數和成員變量，那ArrayList的聲明中爲什麼要添加這個接口？ 原來，List 實現所使用的標記接口，用來表明其支持快速（通常是固定時間）隨機訪問。此接口的主要目的是允許一般的算法更改其行爲，從而在將其應用到隨機或連續訪問列表時能提供良好的性能。

接口Clonable ，java.io.Serializable也是同樣的道理。通過重寫 Object.clone（） 方法來定製對其進行復制的細節,如果在沒有實現 Cloneable 接口的實例上調用 Object 的 clone 方法，則會導致拋出 CloneNotSupportedException 異常。java.io.Serializable

ArrayList的實現

常量

//list初始容量
private static final int DEFAULT_CAPACITY = 10;

變量

/**
* ArrayList中元素存儲的地方，數組的長度就是它的容量
* 不是私有的，方便嵌套類訪問。後面提供了迭代類，需要訪問
*/
transient Object[] elementData;

/**
 *ArrayList所包含的元素的大小 
*/
private int size;

構造方法

/**
 * 使用初始大小創建一個空的list
 *
 * @param  initialCapacity  list初始容量
 * @throws IllegalArgumentException if the specified initial capacity
 *         is negative
 */
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;
    }
}

第一種方法需要一個默認的容量大小; 第二個是默認的構造方法，會默認創建一個容量爲10的 ArrayList ; 第三個則傳給一個 Collection ，注意，不管 Collection 裏面是什麼類型，最後放進 ArrayList 都會上轉爲 Object

此處的bug問題，見下節。

核心方法

add

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // 保證當元素的數量超過內部數組elementData的大小後，自動擴容。防止越界
    elementData[size++] = e;
    return true;
}

add 方法中使用了 ensureCapacityInternal 來控制容量：

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);//根據實際容量判斷是不是要增加elementData容量
}
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

modCount是用來記錄 list被結構修改的次數，所謂結構上的修改是指任何添加或刪除一個或多個元素的操作，或者顯式調整底層數組的大小 ；僅僅設置元素的值不是結構上的修改；在上面的方法中，如果 minCapacity 大於現有數組長度，則執行 grow 方法：

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);//當增長到`newCapacity > MAX_ARRAY_SIZE`時，只能創建Integer.MAX_VALUE大小的數組，不能超過這個值
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

第二個add方法：

public void add(int index, E element) {
    rangeCheckForAdd(index);          //確保插入的位置是在elementData大小範圍內，不會越界。

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

主要使用了 System.arraycopy()方法將 index 之後的元素向後移動一個位置，將 index 位空出來放入新元素

函數原型：System.arraycopy(Object[] src, int srcPos, Object[] dest, int destPos, int length) src: the source array. srcPos: starting position in the source array. dest: the destination array. destPos: starting position in the destination data. length: the number of array elements to be copied.

Clear

public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

clear方法比較簡單，但是也會使modCount+1。

只要添加或刪除元素或者顯示調用底層數組，都會修改modCount

clone

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);
    }
}

clone 方法只能進行淺複製，並不複製元素本身，實際在內部調用的是Object的clone()。

remove

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; // clear to let GC do its work

    return oldValue;
}

刪除指定下標的元素的時候，只是將待刪除後面的元素全部前移，而該元素在內存中的佔用由JVM gc自動處理。

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;
    }

刪除指定對象實例的時候，如果要移除的元素爲 null ，則刪除數組中第一個爲 null 的元素。如果數組中有超過一個匹配的元素，僅移除第一個。

fastRemove(int index)比remove(int index)塊在沒做index關於elementData的邊界檢查。其餘都是一樣的。

toArray

public Object[] toArray() {
	return Arrays.copyOf(elementData, size);
}

這個方法被很多方法使用，它調用了 Arrays 工具類中的方法 copyOf:

public static <T> T[] copyOf(T[] original, int newLength) {
    return (T[]) copyOf(original, newLength, original.getClass());
}

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    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;
}

trimToSize 將此 ArrayList 實例的容量調整爲列表的當前大小。應用程序可以使用此操作來最小化 ArrayList 實例的存儲量。

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}

在 ArrayList 容量確定下來以後，可以調用這個方法最小化存儲空間

Fast-Fail快速失敗機制 此類的 iterator 和 listIterator 方法返回的迭代器是快速失敗的：在創建迭代器之後，除了通過迭代器自身的 remove 或 add 方法從結構上對列表進行修改，否則在任何時間以任何方式對列表進行修改，迭代器都會拋出 ConcurrentModificationException 。因此，面對併發的修改，迭代器很快就會完全失敗，而不是冒着在將來某個不確定時間發生任意不確定行爲的風險。

注意，迭代器的快速失敗行爲無法得到保證，快速失敗迭代器會盡最大努力拋出 ConcurrentModificationException 。迭代器的快速失敗行爲應該僅用於檢測 bug。

ArrayList 中定義了一個 modCount 來記錄對容器進行結構修改的次數，在 add 、 addAll 、 remove 、 clear 、 clone 方法中都會引起 modCount 變化，而在創建迭代器時，會使用局部變量保存當前的 modCount 值：

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;
        ...

在進行迭代的過程中，會先檢查 modCount 有沒有發生變化，以此來判定是否有外部操作改變了容器：

 final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }

因爲 ArrayList 是非同步的，因此，在多線程環境下，如果有對容器進行結構修改的操作，則必須使用外部同步。

關於remove的坑

remove方法有兩種實現：remove(int index),remove(Object obj)。但假設一個ArrayList爲[5,4,3,2,1],先要刪除2這個元素（不是第二號元素！），那麼必須使用remove(new Integer(2))或remove(Integer.valueOf(2))，將2轉爲一個對象實例（不是基礎類型），然後調用remove(Object)方法。

remove(數字)默認調用的是remove(index)。

bug理解

參照下面例子理解bug6260652

package com.hgf.collection.List;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.Test;


/**
 * @see 參考：http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6260652
 * @author hgfdo <a href="hgfdodo.tk">hgf的博客</a>
 *
 */

public class Bug6260652Test {
	
	class BaseClass{
		
	}
	
	class SubClass extends BaseClass{
		
	}
	
	@Test
	public void test1(){
		//subArray 是[Lcom.hgf.collection.List.Bug6260652Test$SubClass;類型
		SubClass[] subArray = new SubClass[3];
		System.out.println(subArray.getClass());
		
		//因爲java向上轉型，所以baseArray 也是[Lcom.hgf.collection.List.Bug6260652Test$SubClass;類型
		BaseClass[] baseArray =subArray; 
		System.out.println(baseArray.getClass());
		
		//異常：java.lang.ArrayStoreException: com.hgf.collection.List.Bug6260652Test$BaseClass
		//因爲baseArray下標0指向的內存區域是SubClass實例，現在要新
		//建一個BaseClass的實例，肯定就會出錯。
		baseArray[0] = new BaseClass();
		
		/*
		 * 總結:有一個Object[]類型的數組，並不到別我們能將所有的類型的
		 * 數據存到數組中，還取決於初始化時的數組元素的實際類型。
		 */
	}
	
	@Test
	public void test2(){
		// 返回的是java.util.Arrays$ArrayList(java.util.Array的內部類)，不是java.util.ArrayList
		List<String> list = Arrays.asList("abc","def");
		System.out.println(list.getClass());
		
		//[Ljava.lang.String;
		Object[] array = list.toArray();
		System.out.println(array.getClass());
		
		//與test1有相同的問題，數組在內存中是有具體的數據類型的，
		//不能將Object類型的數據隨便的賦值給object數組。
		array[0] = new Object();
	}
	
	@Test
	public void test3(){
		//因爲java.util.ArrayList是利用Object[]實現
		//的，list所指向的內存中的數據也是Object類型的，所以
		//使用list.toArray()方法得到的Object[]數組的內
		//存類型就是Object類型，最後可以修改數組裏面的對象實例。
		List<String> list = new ArrayList<String>();

		list.add("aaa");
		list.add("bbb");
		
		//[Ljava.lang.Object;
		Object[] object = list.toArray();
		System.out.println(object.getClass());
		
		//不會出錯，因爲object數組裏面的數據類型就是Object類型的。
		object[0] = new Object();
		
	}


}
/**
 * 總結：
 * 爲了考慮這種情況，所以源碼中進行了if判斷，來防止錯誤的數組對象導致異常。
 * Arrays.copyOf(elementData, size, Object[].class);這個方法就是
 * 用來創建1個Object類型，大小爲size的數組，這樣數組中就可以存放任意對象
 * 了，也將某些在內存中實際不是Object類型的轉爲Object類型，達到與普通情
 * 況中ArrayList利用的數組類型一致。
 */

小結

• ArrayList通過使用私有的Object數組來保存數據，存儲的數據若爲基礎數據，會默認將基礎數據自動裝箱。

• 使用Arrays.copyOf()和List.toArray等方法轉變集合類型時，一定要明確內存中元素真正的類型是什麼，最好使用的時候做類型檢查。

• 使用Array.asList獲取的List對象不是java.util.ArrayList而是java.util.Arrays$ArrayList，java.util.Arrays$ArrayList沒有java.util.ArrayList完美。

• 調用java.util.ArrayList對象的remove方法時，如果參數是int類型而且ArrayList中的元素也是int型，默認執行的是刪除ArrayList的元素，但是就想刪除第i號元素，而不是ArrayList中存儲的i，必須使用

---

Thanks for reading! want more