Java 集合源碼深度解析：AbstractCollection 核心實現與設計哲學

前言：為什麼要讀 AbstractCollection 源碼？

AbstractCollection 是集合框架的骨架實現類，提供了 Collection 接口中除 iterator() 和 size() 之外的通用默認實現。理解其源碼，能洞悉：

1. 集合通用操作（增刪查轉）的標準算法
2. 迭代器模式如何統一遍歷邏輯
3. 併發場景下的弱一致性設計（如 toArray() 的動態擴容）
4. 子類（ArrayList、HashSet 等）為何要重寫特定方法以優化性能

一、Collection 接口核心契約

Collection 定義了集合的基本語義：

• 查詢：size()、isEmpty()、contains()、containsAll()
• 修改：add()、remove()、addAll()、removeAll()、retainAll()、clear()
• 轉換：toArray()、toArray(T[])
• 遍歷：iterator()、forEach() (Java 8+)
• 比較/哈希：equals()、hashCode()

二、AbstractCollection 核心源碼逐節解析 (JDK 17)

2.1 基礎查詢：isEmpty()、contains()

public boolean isEmpty() {
    return size() == 0; // 委派給 size()，子類必須實現
}

public boolean contains(Object o) {
    Iterator<E> it = iterator(); // 統一通過迭代器遍歷
    if (o == null) {
        while (it.hasNext())
            if (it.next() == null) return true; // null 專用比較
    } else {
        while (it.hasNext())
            if (o.equals(it.next())) return true; // 非 null 用 equals
    }
    return false;
}

設計亮點：null 單獨判斷避免 NullPointerException；完全依賴 iterator() 實現算法與數據結構解耦。

2.2 核心難點：toArray() 兩個重載方法

將集合轉為數組看似簡單，實則暗藏併發擴容、類型安全、性能優化三大挑戰。

版本一：Object[] toArray()

public Object[] toArray() {
    Object[] r = new Object[size()]; // 1. 預分配數組
    Iterator<E> it = iterator();
    for (int i = 0; i < r.length; i++) {
        if (!it.hasNext()) // 2. 併發場景：元素變少
            return Arrays.copyOf(r, i); // 截斷返回
        r[i] = it.next();
    }
    // 3. 併發場景：元素變多
    return it.hasNext() ? finishToArray(r, it) : r;
}

版本二：<T> T[] toArray(T[] a) —— 類型安全版本

public <T> T[] toArray(T[] a) {
    int size = size();
    // 1. 判斷傳入數組是否足夠大
    T[] r = a.length >= size ? a : (T[]) java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);
    Iterator<E> it = iterator();
    for (int i = 0; i < r.length; i++) {
        if (!it.hasNext()) { // 元素變少
            if (a == r) r[i] = null; // 填充 null 終結
            else if (a.length < i) return Arrays.copyOf(r, i); // 截斷
            else { System.arraycopy(r, 0, a, 0, i); if (a.length > i) a[i] = null; return a; }
        }
        r[i] = (T) it.next();
    }
    // 元素變多：動態擴容
    return it.hasNext() ? finishToArray(r, it) : r;
}

動態擴容核心：finishToArray()

private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
    int i = r.length;
    while (it.hasNext()) {
        int cap = r.length;
        if (i == cap) { // 擴容觸發點
            int newCap = cap + (cap >> 1) + 1; // 1.5倍 + 1 增長策略
            if (newCap - MAX_ARRAY_SIZE > 0) newCap = hugeCapacity(cap + 1); // 溢出保護
            r = Arrays.copyOf(r, newCap); // 複製到新數組
        }
        r[i++] = (T) it.next();
    }
    return (i == r.length) ? r : Arrays.copyOf(r, i); // 修剪多餘容量
}

關鍵設計決策解讀：

2.3 修改操作：add/remove/containsAll/addAll/removeAll/retainAll/clear

// 默認拋出異常，強制子類實現（如 ArrayList 重寫為真實添加）
public boolean add(E e) { throw new UnsupportedOperationException(); }

// 移除單個元素：通過迭代器遍歷匹配並調用 it.remove()
public boolean remove(Object o) {
    Iterator<E> it = iterator();
    if (o == null) { while (it.hasNext()) if (it.next() == null) { it.remove(); return true; } }
    else { while (it.hasNext()) if (o.equals(it.next())) { it.remove(); return true; } }
    return false;
}

// 批量操作：全部委派迭代器，體現「算法在父類、數據在子類」
public boolean containsAll(Collection<?> c) { for (Object e : c) if (!contains(e)) return false; return true; }
public boolean addAll(Collection<? extends E> c) { boolean mod=false; for(E e:c) if(add(e)) mod=true; return mod; }
public boolean removeAll(Collection<?> c) { boolean mod=false; Iterator<?> it=iterator(); while(it.hasNext()) if(c.contains(it.next())){ it.remove(); mod=true; } return mod; }
public boolean retainAll(Collection<?> c) { boolean mod=false; Iterator<E> it=iterator(); while(it.hasNext()) if(!c.contains(it.next())){ it.remove(); mod=true; } return mod; }
public void clear() { Iterator<E> it=iterator(); while(it.hasNext()){ it.next(); it.remove(); } }

核心洞察：所有批量操作完全依賴迭代器，實現了算法邏輯與具體存儲結構完全分離。子類只需實現 iterator() 返回合適的 Iterator 實例，即可免費獲得所有通用操作。

2.4 toString()：調試利器

public String toString() {
    Iterator<E> it = iterator();
    if (!it.hasNext()) return "[]";
    StringBuilder sb = new StringBuilder('[');
    for (;;) {
        E e = it.next();
        sb.append(e == this ? "(this Collection)" : e); // 防止自我引用無限遞歸
        if (!it.hasNext()) return sb.append(']').toString();
        sb.append(',').append(' ');
    }
}

三、子類重寫策略對比

四、設計哲學總結

1. 模板方法模式：AbstractCollection 定義算法骨架（批量操作、轉數組、toString），子類填充具體數據訪問（iterator、size）。
2. 迭代器統一訪問：屏蔽底層數據結構差異（數組、鏈表、哈希、樹），實現「對數據結構一無所知也能編寫通用算法」。
3. 弱一致性 vs Fail-Fast：父類選擇弱一致性（盡力而為），ArrayList 等選擇 Fail-Fast（快速失敗拋異常），體現不同併發語義權衡。
4. 接口隔離與默認實現：Java 8 前接口無默認方法，AbstractCollection 承擔「接口默認實現」職能；Java 8+ 部分遷移至 Collection.default 方法，但骨架類仍保留價值。

五、實戰啟示

• 自定義集合類優先繼承 AbstractCollection/AbstractList/AbstractSet，僅實現核心抽象方法，免費獲得健壯通用操作。
• 併發場景下，優先使用 Concurrent 集合或不可變集合，避免弱一致性導致業務邏輯錯誤。
• toArray(new T[0]) 比 toArray(new T[size]) 更高效（JVM 優化零長度數組分配），已成最佳實踐。
• 讀源碼核心不在語法，而在權衡決策背後的理由：為什麼 1.5 倍擴容？為什麼 MAX_ARRAY_SIZE -8？為什麼弱一致性？這才是提升架構能力的關鍵。