Java集合框架之接口Collection源碼分析

本文咱們主要學習Java集合框架的根接口Collection，經過本文咱們能夠進一步瞭解Collection的屬性及提供的方法。在介紹Collection接口以前咱們不得不先學習一下Iterable，由於Collection接口繼承了它。

Collection接口類圖

從類圖中咱們看到Collection接口繼承了Iterable接口

Iterable源碼分析

由類圖咱們能夠發現，Iterable接口有三個方法，其中兩個方法使用default修飾的，這是jdk1.8的新特性，容許接口中有默認實現方法，其實現類中能夠有選擇的重寫這部分方法，下面咱們看一下每一個方法的做用是什麼：

#返回元素類型爲T的迭代器，有了這個迭代器就能夠對集合中元素進行遍歷
Iterator<T> iterator();

#遍歷集合中的元素並對元素進行執行操做，直到遍歷完成或拋出異常
default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
         action.accept(t);
    }
}

#Spliterator（splitable iterator可分割迭代器），對集合進行並行遍歷
default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
}

Iterable接口總結：

默認爲全部集合類添加了兩個方法，

一個是遍歷並處理集合元素

一個是可分割迭代器，與方法iterator相比，一個是順序遍歷，一個是並行遍歷

Collection接口源碼分析

//查詢操做，如下方法屬於查詢操做
    #返回集合中元素數量，若是元素數量大於Integer.MAX_VALUE將返回Integer.MAX_VALUE
    int size();

    #若是集合中沒有元素，將返回true，不然返回false
    boolean isEmpty();

    #若是集合中包含指定的元素，則返回true，不然false
    boolean contains(Object o);

    #返回該集合中元素的迭代器。對於返回元素的順序，沒有任何保證。
    Iterator<E> iterator();

    #若是此集合對其迭代器返回的元素的順序有任何保證，則該方法必須以相同的順序返回元素。
    #這個方法必須分配一個新數組，即便這個集合是由數組組成的。
    #這個方法充當集合與數組之間轉換的橋樑
    Object[] toArray();

    #返回一個包含集合中全部元素的數組
    #若是集合中的元素類型與指定數組類型相匹配則直接按照元素中數組類型返回
    #不然，將使用指定數組的運行時類型和該集合的大小分配新的數組。
    #若是此集合對其迭代器返回的元素的順序有任何保證，則該方法必須以相同的順序返回元素。
    #T:返回數組的類型
    #a:若是該數組足夠大能夠容納集合中全部元素，則使用該數組存儲，不然將根據集合大小和元素類型從新建立一個數組
    <T> T[] toArray(T[] a);

    // 修改操做，如下方法屬於修改操做

    #向集合中添加元素，若是該元素在集合中已經存在則返回false，不然返回true
    #集合自己對添加的元素會有所限制，好比有些集合拒絕添加null
    boolean add(E e);

    #從集合中刪除指定元素，若是指定的元素存在集合中並完成了刪除操做，則返回true
    boolean remove(Object o);


    // 批量操做

     #若是集合中包含指定的全部元素，則返回true
    boolean containsAll(Collection<?> c);

    #將指定集合中的全部元素添加到此集合
    #若是在運行過程當中修改指定的集合，則該操做的行爲是未定義的
    boolean addAll(Collection<? extends E> c);

    #從當前集合中移除指定集合中的全部元素
    boolean removeAll(Collection<?> c);

   
    # @since 1.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;
    }

    #只保留集合中指定的元素
    boolean retainAll(Collection<?> c);

    #清空集合中全部元素
    void clear();


    // 比較和散列

    #比較指定對象與當前集合是否相等
    #@see Object#equals(Object)
    #@see Set#equals(Object)
    #@see List#equals(Object)
    boolean equals(Object o);

    #@see Object#hashCode()
    #@see Object#equals(Object)
    #返回當前對象的哈希值
    int hashCode();

    
    #@since 1.8
    #建立一個集合的並行迭代器
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }

   
    #@since 1.8
    #將當前集合做爲數據源，建立一個序列流
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

    #@since 1.8
    #將當前集合做爲數據源，建立一個可並行計算的序列流
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }