在Java中，集合是我們經常要使用的內容，並且集合也是面試的考點之一，掌握集合幫助我們瞭解更多的內部構造。
List
list集合是代表的是一個元素有序的，可重複的集合。
雖然List中有很多子類的實現，但我們經常用的還是那幾個，ArrayList,LinkedList,Vector等內容。
ArrayList
ArrayList 是底層由陣列構成的集合，但是ArrayList有哪些優點呢？
- 能夠做到動態擴容，不再侷限於設定的陣列大小。
- 繼承於List,有集合的操作方式，方便快速的操作書庫，新增，刪除，修改，遍歷等內容。
缺點
- 不是執行緒安全的集合，在操作多執行緒的時候需要採用別的集合例如Vector或者CopyOnWriteArrayList方式。
ArrayList 原始碼解析
基本元素
// 預設的List 集合大小，在建立ArrayList 的時候沒有制定大小 預設是10
private static final int DEFAULT_CAPACITY = 10;
// 預設的空物件
private static final Object[] EMPTY_ELEMENTDATA = {};
// 預設物件內容是該值
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//當前資料物件存放的地方
transient Object[] elementData; // non-private to simplify nested class access
//當前陣列的長度
private int size;
// 陣列最大的長度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 改變list 大小的次數，進行增刪除資料都涉及到此數值
protected transient int modCount = 0;
複製程式碼方法介紹
既然是陣列集合，就需要涉及到陣列的擴容與縮容，在原先我們學習陣列的時候就瞭解，陣列的擴容與縮容都涉及到陣列內的資料的遷移問題。
既然ArrayList 底層是陣列，想當然的也需要涉及到這部分內容。
add方法
add 方法中涉及到增加單個元素，增加單個元素到指定位置，增加一個集合元素，增加一個集合元素到指定位置四個不同型別的方法，但是基本內容是相同的.
public boolean add(E e) {
元素增加 ，在現在的大小上增加1
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
// 計算是否需要進行擴容 ，需要就進行擴容
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 預設的空物件 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
// 判斷 現在list 列表中的元素 是否是空物件。 空物件 返回 最大的值 。不是空物件 返回minCapacity
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
// 擴容結構進行加1
modCount++;
// 進行擴容
// 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);
// 若果擴容後的值還是存放不下 那麼庫容結果直接是 最小的要求容量
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;
}
複製程式碼從以上程式碼來看庫容有以下流程來判斷
- 如果是新建立的集合list 加入資料
- 首先new出來的是集合，不給定引數的情況下，是沒有進行任何容量的初始化的。
- 在執行插入add的時候,會進行容量的初始化10.
- 已經存在的資料量的集合或者指定集合數量
- 在建立的時候指定數量，那麼會初始化這麼陣列空內容。
- 執行插入的時候會進行直接插入。
以上內容新建後的流程，有內容後，就涉及到擴容的問題。
- List 陣列擴容。
- 判斷現在list裡面內容的大小是否超過設定的容量大小。
- 不超過不執行擴容
- 超過執行庫容
- 擴容首先擴大1.5倍的大小容量
- 如果該容量還是不足以放置新增的資料，會直接擴容到最小要求的容量。
- 新的容量大小與最大值進行比較
- 存在負值情況小於0 直接超出內容容量的大小。
- 大於現在最大值直接返回Integer的最大值。
- 說明list不是無限大小的，最大是Integer的最大值。
- 進行資料的copy進行陣列的擴容。 程式碼解釋請看上面
public void add(int index, E element) {
// 指定位置增加資料，需要檢查該位置是否已經被安置資料如果沒有那麼執行失敗
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
// 進行資料的copy 工作，將該位置的資料往後面進行復制
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
然後修改該值
elementData[index] = element;
size++;
}
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
複製程式碼總體新增流程簡單來說是這樣的：
- 判斷是否是新初始化的空集合或者指定了容量的集合
- 進行新增資料判斷是否需要擴容，或者先判斷指定位置資料是否存在
- 擴容後的資料遷移。
ArrayList 集合容量擴容會導致效能問題，Java中複製是需要消耗內容空間，建立同樣數量的物件大小，特別是大批量資料進行庫容容易導致效能下降。
set get
set get 方法沒有需要多說的，根據下標進行資料的讀取與插入，小標註意不要超過集合大小。
remove
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);
//最後的一位置位null 讓gc來處理
elementData[--size] = null; // clear to let GC do its work
返回移除內容
return oldValue;
}
複製程式碼// 批量進行刪除
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
// 判斷不被 刪除的元素是否在集合中 集合是 0 1 2 3 4 5 刪除 1 3 complement = true
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws. 1 3 2 3 4 5 異常執行復制copy 這裡主要是存在可能刪除的元素不在集合中
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// clear to let GC do its work 0 1 size = 6 w = 2
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
複製程式碼刪除程式碼中主要涉及到
- 刪除指定元素，都涉及到陣列內容的拷貝。
迴圈
- for迴圈，根據指標進行迴圈，比較快速
- foreach與迭代器迴圈資料比較適合連結串列式的集合資料
- 刪除集合中的資料使用迭代器，如果使用for指標迴圈刪除資料容易出現異常。