【集合類】源碼解析之 Iterable接口、Collection接口、AbstractCollection抽象類

集合

常用集合類框架圖

Iterable接口

Iterable 代表接口具備迭代能力，實現此接口允許對象成爲“ for-each循環”語句的目標

public interface Iterable<T> {
    // 真正的迭代器
    Iterator<T> iterator();

    // foreach方法 jdk1.8新增
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
	
    // 可分割迭代器 專門用於並行迭代 jdk1.8新增
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

Collection接口

集合只能存放引用類型數據，存的是對象的引用而不是對象本身

類聲明

public interface Collection<E> extends Iterable<E>

集合類的共性方法

int size(); // 返回此集合中的元素數
boolean isEmpty(); // 如果此集合不包含元素，則返回 true 
boolean contains(Object o); // 如果此集合包含指定的元素，則返回 true
boolean containsAll(Collection<?> c); // 如果此集合包含指定集合中的所有元素，則返回true
Object[] toArray(); // 返回一個包含此集合中所有元素的數組
<T> T[] toArray(T[] a); // 返回包含此集合中所有元素的數組; 如果集合長度大於數組長度，則通過反射新建一個數組並且返回的數組類型與參數數組類型一致。如果小於則直接拷貝，多餘位置爲null
boolean add(E e); // 向集合中添加元素
boolean addAll(Collection<? extends E> c); // 將指定集合中的所有元素添加到此集合
boolean remove(Object o); // 從該集合中刪除指定元素的單個實例
boolean removeAll(Collection<?> c); // 刪除指定集合中包含的所有此集合的元素
boolean retainAll(Collection<?> c); // 僅保留此集合中包含在指定集合中的元素
void clear(); // 從此集合中刪除所有元素

// 刪除滿足給定謂詞的此集合中的所有元素 jdk1.8新增
default boolean removeIf(Predicate<? super E> filter) {
    Objects.requireNonNull(filter);
    boolean removed = false;
    final Iterator<E> each = iterator();
    while (each.hasNext()) {
        if (filter.test(each.next())) {
            each.remove();
            removed = true;
        }
    }
    return removed;
}

// 返回以此集合爲源的流 jdk1.8新增
default Stream<E> stream() {
    return StreamSupport.stream(spliterator(), false);
}

// 返回以此集合爲源的並行流 jdk1.8新增
default Stream<E> parallelStream() {
    return StreamSupport.stream(spliterator(), true);
}

/* 從 Iterable 重寫的方法 **/

Iterator<E> iterator(); // 返回迭代器 hasNext()、next()、remove()

// 在此集合的元素上創建Spliterator jdk1.8新增
default Spliterator<E> spliterator() {
    return Spliterators.spliterator(this, 0);
}

AbstractCollection抽象類

實現了 Collection 的部分方法，iterator 和 size 沒有實現

類聲明

public abstract class AbstractCollection<E> implements Collection<E>

方法實現

// 唯一的構造器 給子類初始化使用
protected AbstractCollection() {
}

// 兩個抽象方法由子類具體實現
public abstract Iterator<E> iterator();

public abstract int size();

public boolean isEmpty() {
    return size() == 0;
}

// 通過迭代器判斷元素是否存在
public boolean contains(Object o) {
    Iterator<E> it = iterator();
    // 經常能見到這個元素爲null的分支判斷操作
    if (o==null) {
        while (it.hasNext())
            if (it.next()==null)
                return true;
    } else {
        while (it.hasNext())
            if (o.equals(it.next()))
                return true;
    }
    return false;
}


public Object[] toArray() {
    // 預估的數組大小
    Object[] r = new Object[size()];
    Iterator<E> it = iterator();
    for (int i = 0; i < r.length; i++) {
        // 如果i還在循環，但是迭代器卻沒有下個元素，說明存在併發remove操作，返回數組副本
        if (! it.hasNext()) 
            return Arrays.copyOf(r, i);
        r[i] = it.next();
    }
    // 遍歷結束，還有下個元素說明有併發add操作，擴容，並將剩餘元素添加到數組中，否則直接返回
    return it.hasNext() ? finishToArray(r, it) : r;
}


@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
    // 這裏的size只是估計值
    int size = size();
    // 如果集合長度大於數組長度，則通過反射新建一個數組，如果小於直接拷貝多餘位置爲null
    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++) {
        // 如果i還在循環，但是迭代器卻沒有下個元素，說明存在併發remove操作
        if (! it.hasNext()) { 
            // 如果沒有創建新數組，則將最後一位元素置空
            if (a == r) {
                r[i] = null;
            } else if (a.length < i) {
                // 如果創建了新數組並且當前數組長度大於a的長度，返回當前數組副本
                return Arrays.copyOf(r, i);
            } else {
                // 如果創建了新數組並且當前數組長度小於等於a的長度，將當前數組拷貝給a
                System.arraycopy(r, 0, a, 0, i);
                if (a.length > i) {
                    // 如果a數組長度大於i,則將最後一位置空
                    a[i] = null;
                }
            }
            return a;
        }
        r[i] = (T)it.next();
    }
    // 遍歷結束，還有下個元素說明有併發add操作，擴容，並將剩餘元素添加到數組中，否則直接返回
    return it.hasNext() ? finishToArray(r, it) : r;
}

// 允許分配的最大數組大小，一些 VM 會在數組頭部儲存頭數據，試圖嘗試創建一個比 Integer.MAX_VALUE - 8 大的數組可能會產生 OOM 異常
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

// 擴容，並且將迭代器剩餘的元素添加進數組中
@SuppressWarnings("unchecked")
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;
            // 保證數組的最大長度
            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);
}

// 確保數組的最大容量
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError
        ("Required array size too large");
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

// AbstractCollection 不支持 add
public boolean add(E e) {
    throw new UnsupportedOperationException();
}

// 通過迭代器從列表刪除第一個出現的指定元素
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 modified = false;
    for (E e : c)
        if (add(e))
            modified = true;
    return modified;
}

// 通過迭代器刪除指定集合中的所有元素
public boolean removeAll(Collection<?> c) {
    // 如果傳入的數組爲空則拋NPE
    Objects.requireNonNull(c);
    boolean modified = false;
    Iterator<?> it = iterator();
    while (it.hasNext()) {
        if (c.contains(it.next())) {
            it.remove();
            modified = true;
        }
    }
    return modified;
}

// 通過迭代器保留指定集合中的所有元素
public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);
    boolean modified = false;
    Iterator<E> it = iterator();
    while (it.hasNext()) {
        if (!c.contains(it.next())) {
            it.remove();
            modified = true;
        }
    }
    return modified;
}

// 通過迭代器刪除所有元素
public void clear() {
    Iterator<E> it = iterator();
    while (it.hasNext()) {
        it.next();
        it.remove();
    }
}

public String toString() {
    Iterator<E> it = iterator();
    if (! it.hasNext())
        return "[]";

    StringBuilder sb = new StringBuilder();
    sb.append('[');
    for (;;) {
        E e = it.next();
        sb.append(e == this ? "(this Collection)" : e);
        if (! it.hasNext())
            return sb.append(']').toString();
        sb.append(',').append(' ');
    }
}