Java集合類：AbstractCollection源碼解析

時間 2019-12-08

標籤 java 集合 abstractcollection 源碼解析欄目 Java 简体版

原文原文鏈接

1、Collection接口html

　　從《Java集合：總體結構》一文中咱們知道全部的List和Set都繼承自Collection接口，該接口類提供了集合最基本的方法，雖然List接口和Set等都有一些本身獨有的方法，可是基本的操做相似。咱們先看下Collection接口提供的方法：java

整體上能夠將Collection的方法分爲如下幾大類：數組

一、增長（add/addAll）併發

二、刪除（remove/removeAll/clear/retainAll）app

三、查詢（contain/containAll/iterator/size/isEmpty）學習

四、轉數組（toArray/toArray(T[])）ui

　　直接實現該接口的類只有AbstractCollection類，該類也只是一個抽象類，提供了對集合類操做的一些基本實現。List和Set的具體實現類基本上都直接或間接的繼承了該類。爲了方便之後更清晰的理解這些類的實現，咱們先看下AbstractCollection的實現。this

2、AbstractCollection源碼解析spa

package java.util;

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

    /**
     * 判斷是否包含指定的元素
     * （1）若是參數爲null，查找值爲null的元素，若是存在，返回true，不然返回false。
     * （2）若是參數不爲null，則根據equals方法查找與參數相等的元素，若是存在，則返回true，不然返回false。
     * 注意：這裏必須對null單獨處理，不然null.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;
    }

    /**
     * 功能：將集合元素轉換爲數組
     * 實現：
     * （1）建立一個數組，大小爲集合中元素的數量
     * （2）經過迭代器遍歷集合，將當前集合中的元素複製到數組中（複製引用）
     * （3）若是集合中元素比預期的少，則調用Arrays.copyOf()方法將數組的元素複製到新數組中，並返回新數組，Arrays.copyOf的源碼在後續文章中會分析.
     * （4）若是集合中元素比預期的多，則調用finishToArray方法生成新數組，並返回新數組，不然返回（1）中建立的數組
     */
    public Object[] toArray() {
        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;
    }

    /**
     * 功能：經過泛型約束返回指定類型的數組
     * 實現：
     * （1）若是傳入數組的長度的長度大於等於集合的長度，則將當前集合的元素複製到傳入的數組中
     * （2）若是傳入數組的長度小於集合的大小，則將建立一個新的數組來進行集合元素的存儲
     */
    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) {//若是數組是參數中的數組，則將剩餘部分的值都設置爲null
                    r[i] = null; // null-terminate
                } else if (a.length < i) {//若是傳入的數組長度小於集合長度，則經過Arrays.copyOf將以前數組中的元素複製到新數組中
                    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;
    }

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
     *  功能：數組擴容
     *  （1）當數組索引指向最後一個元素+1時，對數組進行擴容：即建立一個更長的數組，而後將原數組的內容複製到新數組中
     *  （2）擴容大小：cap + cap/2 +1
     *  （3）擴容前須要先判斷是否數組長度是否溢出
     *  注意：這裏的迭代器是從上層的方法（toArray）傳過來的，而且這個迭代器已執行了一部分，而不是從頭開始迭代的
     */
    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);
    }

    /**
     * 判斷數組容量是否溢出，最大爲整型數據的最大值
     */
    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;
    }

    /**
     * 未實現
     */
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

    /**
     * 功能：移除指定元素
     * （1）若是參數爲null，則找到第一個值爲null的元素，並將其刪除，返回true，若是不存在null的元素，返回false。
     * （2）若是參數不爲null，則根據equals方法找到第一個與參數相等的元素，並將其刪除，返回true，若是找不到，返回false。
     */
    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;
    }

    /**
     * 遍歷參數集合，依次判斷參數集合中的元素是否在當前集合中，
     * 只要有一個不存在，則返回false
     * 若是參數集合中全部的元素都在當前集合中，則返回true
     */
    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;
    }

    /**
     * 功能：移除參數集合的元素
     * （1）獲取當前集合的迭代器進行遍歷
     * （2）若是當前集合中的元素包含在參數集合中，則刪除當前集合中的元素
     *  注：只要參數集合中有任何一個元素在當前元素中，則返回true，表示當前集合有發送變化，不然返回false。
     */
    public boolean removeAll(Collection<?> c) {
        boolean modified = false;
        Iterator<?> it = iterator();
        while (it.hasNext()) {
            if (c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

    /***
     * 功能：求參數集合與當前集合的交集
     * （1）獲取當前集合的迭代器進行遍歷
     * （2）若是當前集合中的元素不在參數集合中，則將其移除。
     *  注意：若是當前集合是參數集合中的子集，則返回false，表示當前集合未發送變化，不然返回true。
     */
    public boolean retainAll(Collection<?> 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(' ');
        }
    }

}

　　總體上來講，AbstractCollection的源碼仍是比較容易理解，尤爲是集合增、刪、查等操做都很是簡單。比較複雜的是關於集合轉數組的操做，有幾個點不是特別好理解，這裏解釋一下：設計

　　（1）MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8，爲何最大長度要減8，根據官方的解釋：

/**
* The maximum size of array to allocate.
* Some VMs reserve some header words in an array.
* Attempts to allocate larger arrays may result in
* OutOfMemoryError: Requested array size exceeds VM limit
*/

　　這段話的意思就是有的虛擬機實現，數組對象的頭部會佔用這8個字節。

　　（2）轉換爲數組的操做時，爲何長度會比size()長或者短？這個的緣由仍是考慮到併發狀況下，固然，在併發環境上面的機制不必定可行，如在ArrayList中就重寫了該方法，遇到size()與hasNext不一致的狀況會直接報錯。不過有些場景下能夠經過這種方式保持弱一致性，具體後續遇到這種狀況的時候再具體說明。

　　（3）這裏面執行數組拷貝時，用到兩個方法，一個是Arrays.copyOf，另外一個是System.arraycopy(r, 0, a, 0, i)方法，這兩個方法的區別也會在後續文章中討論，這裏暫不細說。

3、總結

　　本文主要分析了AbstractCollection類的源碼，不少實現類會重寫AbstractCollection中已實現的方法。可是弄明白AbstractCollection源碼以後，再看其子類的實現，會更容易理解其源碼實現背後的設計緣由，其實，不少源碼自己不難理解，難理解的地方在於其背後的設計思想和緣由，這也是咱們去看源碼和真正要學習的東西。