java 集合框架-AbstractCollection

AbstractCollection 作爲頂級接口Collection的抽象實現子類，實現了一下集合基本方法：
- isEmpty
- contains
- toArray
- add
- remove
- containsAll
- addAll
- clear
- toString

下面我們一一看下實現的源碼：

一、isEmpty

判斷集合是否爲空

    /**
     * {@inheritDoc}
     *
     * <p>This implementation returns <tt>size() == 0</tt>.
     */
    public boolean isEmpty() {
        return size() == 0;
    }

判斷集合是否爲空，使用了size是否爲空判斷，但是該抽象類咩有實現size()方法，改方法的正確的性，依賴於子類實現size()方法的邏輯必須集合爲空是size()=0；

二、contains

判斷對象是否在集合中

    /**
     * {@inheritDoc}
     *
     * <p>This implementation iterates over the elements in the collection,
     * checking each element in turn for equality with the specified element.
     *
     * @throws ClassCastException   {@inheritDoc}
     * @throws NullPointerException {@inheritDoc}
     */
    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;
    }

判斷對象是否存在於集合中，由於集合可以存在null元素，改方法入參也有Null的可能，分兩種情況遍歷判斷是否存在相等的元素；非空情況下，該方法的正確性會依賴於對象的equal方法是否正確；

三、toArray

獲取包含集合中所有元素的對象數組

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

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

返回的數組是新創建的，並不是返回集合內部的數組；
使用迭代器遍歷獲取元素，可以看出這代碼允許在迭代中集合元素個數發送變化：當元素減少，再截斷複製一個數組返回；當元素增加，再使用 finishToArray 方法補全；finishToArray方法中會保證數組最大值；從源碼可以看出，這些方法不是線程安全，當獲取數組時，如果集合大小不斷變化會發生不可預料的錯誤；

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

toArray的帶入參重載函數，入參爲一個元素數組，在入參數組足夠大容納集合中元素是，使用這個數組返回，否則新創建數組返回；

四、add

    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

還不是很清楚爲什麼不支持這個操作還要實現這個方法？

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

與contains方法類是，使用迭代器遍歷，分null與非null兩種情況判斷是否存在，存在在移除，不存在返回false；

六、containsAll

判斷入參集合是否全部都在集合中存在

    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

遍歷調用contains方法判斷是否存在，如有存在的元素，這個返回false，依賴contains方法正確性；

七、addAll

添加入參集合全部元素到集合中

    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }

遍歷入參集合，將每個元素添加到集合中，返回值在add方法不能添加時返回false會導致結果不正確，導致部分成功添加也返回true；

八、removeAll

從集合中移除所有入參中集合中存在的元素

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

遍歷入參集合，元素是否存在集合中，存在則移除；

九、retainAll

保留入參集合中元素，其他移除

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

代碼和removeAll方法基本一樣，邏輯相反；

十、clear

清空集合所有元素

    public void clear() {
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
    }

使用迭代器遍歷所有元素並移除；

十一、toString

    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(' ');
        }
    }

可以看出，平時使用List和Set的toString方法打印出來的格式就是這樣，這裏有一點需要注意，就是當集合元素中包含集合本身時，爲不無限遞歸，只會打印”(this Collection)”；

AbstractCollection 抽象類實現的部分基礎方法都比較簡單，基本全部依賴於Iterator迭代器實現，可見集合框架中迭代器的重要性；