JDK1.8集合類學習< AbstractCollection>

AbstractCollection這個抽象類是開發者基於Collection接口的基礎上實現了很多功能。有時候具體的實現類並不想實現接口的所有方法，而如果繼承AbstractCollection這個抽象類，只需要實現其抽象方法就行，這也是集合元素所必須的，其他的方法就可以選擇性的進行重寫。

抽象類AbstractCollection實現了Collection接口

public abstract class AbstractCollection<E> implements Collection<E> 

只有一個默認構造器

	protected AbstractCollection() {
    }

抽象方法

返回這個集合中包含元素的一個迭代器。此集合數組元素數量。

	public abstract Iterator<E> iterator();

    public abstract int size();

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()) // 比期望的要小①
                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();
        //先判斷給定的數組a和當前的元素數量，保證r的容量不小於size
        T[] r = a.length >= size ? a :
                  (T[])java.lang.reflect.Array
                  .newInstance(a.getClass().getComponentType(), size);
        Iterator<E> it = iterator();
		/*  
		 *  r.length是>=size的，此時集合中的元素可能因爲併發減少
		 *  if it.hasNext()==false，
		 *  1)a=r，集合中沒有元素了，否則不會被執行，此時返回空的a數組
		 *  2)a.length < i，即給定數組容量比集合剩餘的元素的數量小，類似於
		 *  上面的toArray(),調用Arrays.copyOf(r, i)複製數組，
		 *  返回數組r，
		 *  3)else 即給定數組容量不小於集合剩餘的元素的數量,
		 *  把r的元素複製到a,
		 *  a[i]即a[集合真實長度+1]爲空，返回a
		 */
        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;
    }

如果元素變多，第一次執行進行擴容並把元素拷貝到新容量的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);
    }

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

此抽象類沒有給出add和addAll方法的具體實現。需要實現類自行實現。

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

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

containsAll和contains

	public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return 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;
    }

remove和removeAll和retainAll

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