Java中集合類源碼分析(2)-----Collection和AbstractCollection源碼分析

這是該系列文的第二篇,本文介紹了Collection以及它的一個直接實現類AbstractCollection, 這是一個抽象類,其實現了很多方法,也保留了一些抽象方法.Collection 下的大多數子類都繼承自AbstractCollection ，比如 List 的實現類, Set的實現類.下面我們首先來看看Collection.

1.Collection接口

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public interface Collection<E> extends Iterable<E> {

    /**
     * 返回集合中元素的數量,如果集合包含了大於Intger.MAX_VALUE個元素,返回Integer.MAX_VALUE
     */
    int size();

    /**
     * 若集合中沒有元素,返回true
     */
    boolean isEmpty();

    /**
     *如果這個集合包含指定的元素,返回true  
     *
     *如果指定元素的類型和這個集合的類型不同,拋出ClassCastException異常
     *
     *如果指定元素爲null並且這個集合沒有準許null元素.        
     */
    boolean contains(Object o);

    /**
     *返回一個擁有這個集合內元素的迭代器.這裏並沒有對元素的返回順序進行保證,即對順序沒有保證
     *(除非這個集合是某些提供了順序保證的類的實例)
     */
    Iterator<E> iterator();

    /**
     *返回一個包含這個集合中所有元素的數組.
     *如果這集合保證了其在迭代器中迭代的元素順序的話,這個方法的返回也必須按照相同的順序
     *
     *返回的數組將是"安全"的,因爲沒有由集合維持着的對數組的引用.(換句話說,
     *這個方法必須分配一個新的數組給這個集合,哪怕這個集合底層本來就是數組)
     */
    Object[] toArray();

    /**
     *返回包含此 collection 中所有元素的數組；返回數組的運行時類型與指定數組的運行時類型相同。
     *例:
     *下面的這個x應該是一個只由字符串組成的集合.下述代碼被用來把一個集合放入到一個String類型的數組裏面
     *     String[] y = x.toArray(new String[0]);</pre>
     *
     * 注意toArray(new Object[0])和toArray()是完全等同的.
     *
     * @param 這個集合中元素組成數組的類型
     * @param 將存儲這個集合的元素,確保他是足夠大的,否則,一個和和它相同類型的合適大小的數組將被分配來做這件事
     * @return 一個包含了這個集合內元素的類型的數組
     *         當給定數組的運行時類型(泛型)與集合元素的類型不相同時,拋出 ArrayStoreException
     * @throws NullPointerException 當指定的數組爲null時
     */
    <T> T[] toArray(T[] a);

    // Modification Operations

    /**
     *感覺源碼廢話有點多..
     *就是向集合裏面添加一個元素,添加成功了返回true
     *有些集合不允許重複,若添加的元素在原集合裏面有了,則返回false
     */
    boolean add(E e);

    /**
     *從集合中移除一個元素,如果該指定的元素在集合中是有的,返回true
     *
     * @throws ClassCastException 當指定的參數類型不能轉換爲集合聲明的類型      
     * @throws NullPointerException 當指定的元素爲null並且集合不允許存在空元素  
     * @throws UnsupportedOperationException 當remove操作不被該集合支持
     */
    boolean remove(Object o);


    // Bulk Operations

    /**
     * 當參數集合c中的所有元素都包含於這個集合時,返回true,否則爲false
     */
    boolean containsAll(Collection<?> c);

    /**
     *將指定集合中的所有元素都添加到此集合中,添加成功返回true
     *
     */
    boolean addAll(Collection<? extends E> c);

    /**
     * 移除此集合中指定集合的所有元素 ,求指定集合和該集合的差集.
     * 做了這樣的操作後,這兩個集合將沒有相同的部分
     */
    boolean removeAll(Collection<?> c);

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

    /**
     *僅僅保留那些在給定集合與本身集合都有的部分,求交集,換句話說,移除原集合中存在,而指定集合中不存在的元素
     *
     */
    boolean retainAll(Collection<?> c);

    /**
     * 清空所有元素,只剩容器
     */
    void clear();


    // Comparison and hashing

    /**
     * Compares the specified object with this collection for equality. <p>
     *比較給定的集合是否與給定集合相等
     *
     *這段源碼說得挺好,我來翻譯翻譯
     * 當這個集合接口並沒有對Object.equals給出條條款款來修改時,程序員直接實現這個接口(換句話說,創造一個類,他是一個Collection,
     * 但不是一個Set或者List)必須關係是否選中覆蓋這個Object.equals方法.這並不是必須的,最簡單的做法就是依賴於Object的做法,
     * 但是實現者可能關心的是"值之間的比較"而不是默認的"引用間的比較"(List和Set已經授權了這種值之間的比較,它們比的是值)
     * 
     * 通常Object.equals方法必須是對稱的.(比如a.equals(b),那麼b.equals(a))List.equals()和Set.equals()
     * 的公約聲明瞭List只能和List相等,Set只能和Set相等.因此,一個集合類的常規的equals方法中,List與Set比較,是要返回false
     * 的.(由這個邏輯,不可能創建一個即實現Set又實現List的類)
     *
     */
    boolean equals(Object o);

    /**
     *返回該集合的hashcode.
     * @return the hash code value for this collection
     */
    int hashCode();

    //8的新特性,先留在這,以後來填坑 
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }


    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }


    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

2.AbstractCollection



package java.util;

import java.util.Arrays;
import java.util.Collection;
import java.util.Objects;

/**
 * 這個類提供了一個對於Collection接口具體實現的骨架,縮小了對這個接口實現的要求(事實上後面很多類繼承自這個類)
 *
 * 程序員應該提供一個無參構造..balabala(作者推薦使用的人自己在子類中自己創建一個無參構造)
 *
 * 文檔對這個類裏面的每一個非抽象方法都描述了它的詳細內容.當集合類的實現方法被實現得更高效時,這些方法是能夠被覆蓋的
 *
 * 這個類是Java集合類框架結構的一部分
 */

public abstract class AbstractCollection<E> implements Collection<E> {
    /**
     * 由子類調用的無參構造方法
     */
    protected AbstractCollection() {
    }

    // 查詢操作

    /**
     * 返回一個這個集合中的元素的迭代器,這是一個抽象方法,子類必須以自己的方式實現這兩個方法。
     */
    public abstract Iterator<E> iterator();

    public abstract int size();

    /**
     * 返回是該集合是否爲空,依靠size完成
     */
    public boolean isEmpty() {
        return size() == 0;
    }

    /**
     * 判斷是否包含某元素,底層是迭代器完成的 它將檢查集合中每一個元素是否和給定元素相等(equals方法實現)
     */
    public boolean contains(Object o) {
        Iterator<E> it = iterator();
        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;
    }

    /**
     * 通過這個集合的迭代器,這個方法實現返回一個包含着這個集合中所有元素的數組,以與迭代順序相同的順序,將元素連續存入數組,從索引0開始
     * 該數組長度等同於集合元素個數即迭代器返回個數,即使在迭代過程中集合發生了改變,可能發生併發改變如果集合允許的話
     *
     * <p>
     * This method is equivalent to:
     *
     * <pre>
     * {
     *  &#64;code
     *  List<E> list = new ArrayList<E>(size());
     *  for (E e : this)
     *      list.add(e);
     *  return list.toArray();
     * }
     * </pre>
     */
    public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (!it.hasNext()) // fewer elements than expected
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    /**
     * 下面這個是泛型
     */
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        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()) { // fewer elements than expected
                if (a == r) {
                    r[i] = null; // null-terminate
                } 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();
        }
        // more elements than expected
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    /**
     *分配給數組長度的最大值. 一些虛擬機在數組中保留着一些個頭信息.企圖分配更大的數組長度可能導致OutOfMemoryError:
     *Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     *這是一個靜態私有方法,用在toarray中,如果size的大小小於迭代器迭代的元素。則調用finishToArray來完成之後迭代器的實現。 
     *當迭代器返回元素個數超出預想時,在轉化爲數組時重新分配數組,從迭代器中填滿後結束.
     *
     *( 這個方法保存兩個int。一個表示當前的迭代的元素的數量，i每次進入循環體就增加一個，而另一個cap表示當前的數組的大小。
     *  每次進入循環體，先用cap確認下數組的長度。如果i還沒有增長到cap相同的程度則只要將迭代器的下一個元素放入數組並將i加一就行
     *  如果i==cap的時候說明需要增大cap。這裏增加的cap的一半並加1的大小，然後判斷下新的數組的大小是否超過VM的最大界限，如果沒有就將繼續循環體。
     *  在返回的時候使用根據已經迭代的元素i來複制當前數組到一個新的數組中。
     *  這裏如果判斷newCap大小超過了最大的數組大小則調動hugeCapacity調整大小。)
     *
     * @param r
     *           填充着之前元素的數組
     * @param it
     *           這個集合所進行的迭代器
     * @return 
     *        一個數組,它 包含着之前給定數組中的元素,加上這個迭代器迭代出來的元素,並修整其數組長度
     */
    @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;
                // overflow-conscious code
                if (newCap - MAX_ARRAY_SIZE > 0)
                    newCap = hugeCapacity(cap + 1);
                r = Arrays.copyOf(r, newCap);
            }
            r[i++] = (T) it.next();
        }
        // trim if overallocated
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }
    /*
     * 用於確定確定數組極限的值的方法
     * 
     * 如果當前的cap最大值不可在繼續增大，即cap+1爲負值則拋出一個超出內存大小的異常。
     *如果當前的值可以分配，則分配一個MAX_ARRAY_SIZE和MAX_VALUE 中的滿足條件的值。
     *
     */
    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(E) 方法默認是拋出異常的，爲什麼要這樣做?爲什麼不定義爲抽象方法?
     * 
     *  如果你想修改一個不可變的集合時，拋出 UnsupportedOperationException 是標準的行爲，比如 當你用 Collections.unmodifiableXXX() 方法對某個集合進行處理後，
     *  再調用這個集合的 修改方法（add,remove,set…），都會報這個錯；
     *  因此 AbstractCollection.add(E) 拋出這個錯誤是準從標準；
     *  那爲什麼會有這個標準呢？
     *  
     *  在 Java 集合總，很多方法都提供了有用的默認行爲，比如：
     *  
     *  Iterator.remove()
     *  AbstractList.add(int, E)
     *  AbstractList.set(int, E)
     *  AbstractList.remove(int)
     *  AbstractMap.put(K, V)
     *  AbstractMap.SimpleImmutableEntry.setValue(V)
     *  而之所以沒有定義爲 抽象方法，是因爲可能有很多地方用不到這個方法，用不到還必須實現，這豈不是讓人很困惑麼。
     *  
     *  個人覺得原因跟和設計模式中的 接口隔離原則 有些相似：
     *  
     *  不要給客戶端暴露不需要的方法。     ----引自<< Java 集合深入理解（5）：AbstractCollection>>拭心
     *
     */
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

    /**
     *這個方法的實現是重複迭代這個集合來尋找(通過o.equals方法來確定的)指定的元素.如果找到這個元素,調用迭代器的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;
    }

    // Bulk Operations

    /**
     *這個方法的實現是通過迭代給定的集合,檢查每個迭代器返回的元素是否被包含在源集合中, 
     *如果全部包含就返回true,底層用的是contains方法
     */
    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

    /**
     * <p>
     *這個方法的實現是迭代給定的集合,通過迭代器依次添加每一個元素到集合中,底層用的是add方法
     *
     * 除非add被覆蓋,否則這個方法會報錯:UnsupportedOperationException
     * (assuming the specified collection is non-empty).
     */
    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }

    /**
     * 這個方法的實現是通過迭代這個集合,檢查每一元素是否被包含在給定的集合中,如果是的話,則調用迭代器的remove將其移除
     * 相當於求兩集合的差集
     */
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        Iterator<?> it = iterator();
        while (it.hasNext()) {
            if (c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

    /**
     *這個實現通過迭代這個集合,檢查每一個迭代出來的元素是否被包含在指定的集合中.如果不被包含,那麼將被這個集合的迭代器移出
     *(底層也是contains方法,contains方法的底層是equals方法實現)
     */
    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;
    }

    /**
     *這個實現是通過迭代器迭代出集合中的所有元素,用Itreator.remove操作移除每一個迭代出的方法.
     *大多數實現爲了跟高效的性能,可能會選擇覆蓋這個方法
     *
     *同樣,如果iterator的remove方法本身爲得到實現,也會拋出UnsupportedOperationException
     *
     */
    public void clear() {
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
    }

    // 字符串轉換

    /**.
     * 返回一個該集合的字符串表示.這個字符串表示包含着該集合的元素列表,它的順序是按照迭代順序的,同時包含方括號[].
     * 相鄰的兩個元素由", "隔開(逗號和空格)元素被轉換爲字符串,底層方法爲String.valueOf(Object)
     *
     * @return a string representation of this collection
     */
    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(' ');
        }
    }

}

Java中集合類源碼分析(2)-----Collection和AbstractCollection源碼分析

1.Collection接口

2.AbstractCollection

[算法系列]遞歸應用——二叉樹（1）：二叉樹遍歷詳解解+LeetCode經典題目+模板總結

[算法系列]搞懂DFS(2)——模式套路+經典例題詳解（n皇后問題，素數環問題）

[算法系列]優先隊列,堆與堆排序

PC機與開發板間搭建nfs

[算法系列]數據結構之——圖(1)：接口定義與實現+DFS+BFS

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結