AbstractCollection介紹

1. AbstractCollection抽象類是Collection的基本實現，其實現了Collection中的大部分方法，可以通過繼承此抽象類以最少的代價來自定義Collection；

2. 如果要定義一個不可變Collection，只需要繼承此類，並實現iterator和size方法，其中iterator方法返回的迭代器必須實現hasNext和next方法；
3. 如果要定義一個可變Collection，只需要繼承此類，並實現iterator，size和add（預設會拋出UnsupportedOperationException）方法，其中iterator方法返回的迭代器必須實現remove方法；
4. 按照Collection介面中的規定，客戶端程式員應該提供一個無參構造和以Collection為參數的有參構造；
5. 此抽象類的子類可以用更有效率的方式覆蓋父類的方法；

　　/**
     *從Collection中繼承過來的抽象方法 
     */
    public abstract Iterator<E> iterator();
    public abstract int size();
    /**
     *直接返回 size() == 0，與size()的具體實現無關
     */
    public boolean isEmpty() {
         return size() == 0;
     }
    /**
     * 通過迭代器遍歷所有元素，用equals方法比較，只要有一個符合條件的元素則返回true
     */
    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;
    }
    /**
     * 通過迭代器遍歷集合中，轉換為數組
     * 等價於
     * List<E> list = new ArrayList<E>(size());
     * for (E e : this)
     *     list.add(e);
     * return list.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;
    }
    /**
     * 同上面的方法類似，比上面的方法常用，優點在於返回的數組不用做類型轉換
     * 當參數數組容量不夠時，將返回一個新的數組
     */
    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;
    }
    /**
     * 預設不支持add
     */
    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }
    /**
     * 迭代器遍歷集合，通過equals找到符合條件的元素，將其移除
     * 對於不可變集合，其迭代器的remove方法中會拋出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;
    }
    /*
     * 迭代器迴圈遍歷集合，調用自身的contains方法
     */
    public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }
    /**
     * foreach迴圈，調用自身add方法
     * 添加成功返回true,失敗返回false
     */
    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) {
        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();
        }
    }
    /**
     * 重寫了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(' ');
        }
    }