Collection接口

Collection

    Collection是List、Queue和Set的超集，它繼承於Iterable，也就是說Collection集合類都支持for-each操做。

方法定義

//返回集合長度，若長度大於Integer.MAX_VALUE，則返回Integer.MAX_VALUE
int size();

//若是集合元素爲0，返回true
boolean isEmpty();

//依據equal()方法判斷集合中是否包含指定元素
boolean contains(Object o);

//返回一個含有集合中全部元素的數組
Object[] toArray();

//同上，增長了類型轉換
<T> T[] toArray(T[] a);

//向集合中加入一個元素，成功返回true，失敗或已包含此元素返回false
boolean add(E e)

//刪除指定元素
boolean remove(Object o);

//若該集合包含指定集合全部元素，返回true
boolean containsAll(Collection<?> c);

//將指定集合的元素添加到該集合中
boolean addAll(Collection<? extends E> c);

//從集合刪除指定集合中的元素
boolean removeAll(Collection<?> c);

//僅僅保留集合中包含在指定集合的元素
boolean retainAll(Collection<?> c);

//清空集合
void clear();

//將此方法抽象，是保證全部子類都覆寫此方法，以保證equals的正確行爲
boolean equals(Object o);

//同上
int hashCode();

//這個方法在JDK1.8中提供了默認的實現，會使用Iterator的形式刪除符合條件的元素
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;
}

 

AbstractCollection

    是Collection接口的一個重要實現類，爲抽象類。 若是要實現一個不可修改的集合，須要重寫iterator和size接口，而且返回的Iterator須要實現hasNext和next。而要實現一個能夠修改的集合，還必須重寫add方法（默認會拋出異常），返回的Iterator還須要實現remove方法。

方法定義

public abstract Iterator<E> iterator();

public abstract int size();

public boolean isEmpty() {return size() == 0;}

//這個方法由於Iterator的存在，能夠進行一致性封裝，這裏須要注意的是對象的比較是經過equals方法，由於調用到了it.next()
//與it.hasNext()，這也是爲何文檔註釋會寫實現集合類須要重寫Iterator的這兩個方法。
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;
    }

//同上，刪除也用到了Iterator
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;
    }

//其他方法也要用到Iterator特性，如containsAll(Collaction<?> c)、allAll(Collection<? extends E> c)、
//clear()等

//這個實現相對複雜一些，能夠看到擴容最主要的手段是Arrays.copyOf()方法，
//也就是須要將原數組經過複製到新的數組中來實現的。
//在這裏實現是爲了方便不一樣具體實現類互相轉換，咱們在後續會屢次見到此方法
public Object[] toArray() {
    //先根據當前集合大小聲明一個數組
    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();
    }
    //元素比從size()中獲取的更多，就須要進一步調整數組大小
    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;
        //r的長度不夠，繼續分配
        if (i == cap) {
            //擴充方式爲cap+cap/2+1，也就是1.5倍擴容
            int newCap = cap + (cap >> 1) + 1;
            // 超過了最大容量，MAX_ARRAY_SIZE=Integer.MAX_VALUE-8
            if (newCap - MAX_ARRAY_SIZE > 0)
                //從新設置cap的值
                newCap = hugeCapacity(cap + 1);
            
            //對r進行擴容
            r = Arrays.copyOf(r, newCap);
        }
        //賦值，進入下一輪循環
        r[i++] = (T)it.next();
    }
    // 因爲以前擴容是1.5倍進行的，最後再將其設置到和r實際須要的相同
    return (i == r.length) ? r : Arrays.copyOf(r, i);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // 超過了最大正整數，也就是負數
        throw new OutOfMemoryError
            ("Required array size too large");
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

//toString經過StringBuilder拼接每一個元素的roString完成。
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(' ');
        }
    }