3-1、java.util.AbstractCollection

1、java.util.AbstractCollection

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 ;
    }
    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;
    }
    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() ;
        }
        return it.hasNext() ?  finishToArray(r , it) : r ;
    }

    public < T>  T[]  toArray( T[] a) {
        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()) {
                if (a == r) {
                    r[i] =  null;
                }  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() ;
        }
        return it.hasNext() ?  finishToArray(r , it) : r ;
    }

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

    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 ;
                if (newCap -  MAX_ARRAY_SIZE >  0)
                    newCap =  hugeCapacity(cap +  1) ;
                r = Arrays. copyOf(r , newCap) ;
            }
            r[i++] = ( T)it.next() ;
        }
        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() ;
    }

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

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

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

说明：

此类提供 Collection 接口的骨干实现，以最大限度地减少了实现此接口所需的工作。

要实现一个不可修改的 collection，编程人员只需扩展此类，并 提供 iterator 和 size 方法的实现。

要实现可修改的 collection，编程人员必须另外重写此类的 add 方法（否则，会抛出 UnsupportedOperationException），

iterator 方法返回的迭代器必须实现 hasNext 和 next。

iterator 方法返回的迭代器还必须另外实现其 remove 方法。

按照 Collection 接口规范中的建议，编程人员通常应提供一个 void （无参数）和 Collection 构造方法。

此类中每个非抽象方法的文档详细描述了其实现。

如果要实现的 collection 允许更有效的实现，则可以重写这些方法中的每个方法。

toString()方法中：

sb.append(e == this ? "(this Collection)" : e);//e==this的时候没有调用e.toStrting避免了递归调用。

for(;;)//没有限制循环条件，和while(true).

继承此类的子类：

抽象类：AbstractList AbstractSet AbstractQueue 

类：HashMap内部类Values  TreeMap内部类Values  双端队列：ArrayDeque