java基礎集合類——ArrayList 源碼略讀
ArrayList是java的動態數組，底層是基於數組實現。
1. 成員變量
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { /** * The maximum size of array to allocate. * Some VMs reserve some header words in an array. * Attempts to allocate larger arrays may result in * OutOfMemoryError: Requested array size exceeds VM limit */ private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. */ private static final Object[] EMPTY_ELEMENTDATA = {}; /** * Shared empty array instance used for default sized empty instances. We * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when * first element is added. */ private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; /** * The array buffer into which the elements of the ArrayList are stored. * The capacity of the ArrayList is the length of this array buffer. Any * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA * will be expanded to DEFAULT_CAPACITY when the first element is added. */ transient Object[] elementData; // non-private to simplify nested class access /** * The size of the ArrayList (the number of elements it contains). * * @serial */ private int size;
一個個來看一下這些成員變量。
elementData
這是ArrayList的基本數據類型，因為java並沒有真的實現底層泛型，而是通過實現編譯類型擦除的方式實現了泛型的效果。因此，底層的數組是Object[]類型。size
這個並不是指elementData數組的長度，而是有效存儲信息的長度，初始化時為0DEFAULT_CAPACITY
這是一個常量，這是初始化時elementData的長度。DEFAULTCAPACITY_EMPTY_ELEMENTDATA & EMPTY_ELEMENTDATA
這兩個都是常量，而且都是空數組。MAX_ARRAY_SIZE
最大數組長度，超過此長度會報錯
2. 成員函數
學習成員函數的代碼，主要是看外部變動發生時，底層數組會怎麽變化。其實吧，ArrayList並不復雜，無法怎麽變化，都是elementData的增刪改查，剩下的無非是對效率的優化。
2.1 初始化
/** * Constructs an empty list with the specified initial capacity. * * @param initialCapacity the initial capacity of the 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); } } /** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } /** * Constructs a list containing the elements of the specified * collection, in the order they are returned by the collection's * iterator. * * @param c the collection whose elements are to be placed into this list * @throws NullPointerException if the specified collection is null */ 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; } }
這裏有三個有趣的初始化方法。
帶初始化capacity參數
這個不用說，直接用capicity來初始化elementData數組，再加上對傳入參數的防禦性檢查，其他的沒了。不帶初始化參數
這個直接用DEFAULTCAPACITY_EMPTY_ELEMENTDATA賦值給elementData傳入一個集合實例
這個方法也很有趣，如果傳入的集合不為空，則不用說，直接將對方的數組復制過來就行。但是如果對方為空列表，elementData賦值為EMPTY_ELEMENT_DATA。為什麽不用DEFAULT_ELEMENT_DATA，主要不同點在於添加元素時的應對策略不同。
2.2 追加元素時
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
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);
// minCapacity is usually close to size, so this is a win:
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;
}這方法調用鏈還挺長的，先從頭來。
add(Object e)
很簡單的思路，直接將當前有效元素最大索引後面的位置放置這個新增元素就行，然後將size++。唯一需要考慮的是，如果當前數組已經放滿的時候，或者為空的時候（例如前面不帶初始化capacity會將elementData賦值為空數組），這個時候需要對數組進行擴充了。ensureCapacityInternal
這裏可以看出來DEFAULT_EMPTY_ELEMENTDATA與EMPTY_ELEMENTDATA的區別了，如果是DEFAULT_EMPTY_ELEMENTDATA，直接擴充為10，如果為EMPTY_ELEMENTDATA，實際上也被視為是有值的，會根據0的size來進行擴充。擴充的策略看方法3。ensureExplicitCapacity
簡單的校驗，如果當前length已經不足以支持新的元素，需要擴充。擴充策略見方法4。grow
不看那些防禦性代碼，ArrayList的防禦性措施只有一個，擴充為原先size的150%。因此如果elementData為EMPTY_ELEMENTDATA，則擴充為1，如果為DEFAULT_EMPTY_ELEMENTDATA，則擴充為10。
為什麽這樣考慮，我想主要類型一致，因為初始化時傳入一個原始列表長度為6，則首輪擴充要擴充到9個，既然同類都擴充為原先的150%，那麽傳入一個空列表憑什麽可以擴充不符合規劃的10，除非將空列表排除出列表的範圍。這樣做也是挺合理，就是這個實現方式有點惡心，而且這個變量命名非常不好，容易混淆。
而且也需要註意到這個擴充幅度不大，可以節省空間，但是如果需要加入特別大的size隊列時，那就需要擴充相當多次，這時還是比較推薦初始化就設置好對應的capacity比較好。
2.3 中間添加元素
這是一個比較惡心的方法，你需要將原先在這個位置的元素往後移，而且還要將這個原先元素後面的所有元素都往後移，才能空出空間給新增元素。耗時耗力，總之，很惡心的代碼。
/**
* Inserts the specified element at the specified position in this
* list. Shifts the element currently at that position (if any) and
* any subsequent elements to the right (adds one to their indices).
*
* @param index index at which the specified element is to be inserted
* @param element element to be inserted
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public void add(int index, E element) {
rangeCheckForAdd(index); // 防禦性措施，無實質作用
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
2.4 移除代碼
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;
}刪除時，將直接將後面的元素移到前面覆蓋，註意將最後一個元素轉為null，這是為了讓已經不使用的元素能夠被gc掉。
2.5 清空
/**
* Removes all of the elements from this list. The list will
* be empty after this call returns.
*/
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}這個clear需要額外註意，從源碼看得出來，clear時只會將elementData的引用置為null，但是elementData數組的長度並沒有縮減。如果在大數據量下，需要復用ArrayList，reset的時候僅是調用了clear方法，會導致不小的內存被elementData數組所占用。
2.6 其他方法
像iterator，foreach之類的方法大概也沒什麽好講的，ArrayList篇先這樣。
java基礎集合類——ArrayList 源碼略讀