Java集合之AbstractCollection

//此类提供 Collection 接口的骨干实现，以最大限度地减少了实现此接口所需的工作(Jdk:1.7   java.util)
public abstract class AbstractCollection<E> implements Collection<E> {
    
    protected AbstractCollection() {//供子类使用，通常为protected
    }
    public abstract Iterator<E> iterator();//返回在此 collection 中的元素上进行迭代的迭代器。 

    public abstract int size();//返回此 collection 中的元素数
    public boolean isEmpty() {//如果此collection 不包含元素，则返回 true。 
        return size() == 0;
    }
    public boolean contains(Object o) {//如果此 collection 包含指定的元素，则返回 true
        Iterator<E> it = iterator();
        if (o==null) {
            while (it.hasNext())
                if (it.next()==null)//当o为null，如果集合也包含null元素时，返回true
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))//o不为null时，若包含o，也返回true
                    return true;
        }
        return false;
    }
    public Object[] toArray() {
        Object[] r = new Object[size()];
        Iterator<E> it = iterator();
      //循环中 ，如果其它线程删除了元素，则length变小会提前结束循环，第二个return去调用新的方法
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext())//如果没有下个元素了。就直接复制该数组返回
                return Arrays.copyOf(r, i); //浅复制
            r[i] = it.next();
        }
      //循环结束，迭代器还有元素可以迭代时调用finishToArray
        return it.hasNext() ? finishToArray(r, it) : r;//集合长度为0时，数组大小也为0。默认初始化
    }
    //返回包含此 collection中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同
    public <T> T[] toArray(T[] a) {
        int size = size();
      //a长度较大时，复制a的引用给r；较小时，new一个数组，长度为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; //剩余长度用null补齐
                } else if (a.length < i) {//a的长度太小时直接将r拷贝i长度返回
                    return Arrays.copyOf(r, i);//新建数组，复制长度为i的r数组返回。浅复制
                } else {
                    System.arraycopy(r, 0, a, 0, i);
                    if (a.length > i) {
                        a[i] = null;
                    }
                }
                return a;
            }
            r[i] = (T)it.next();
        }
        //循环结束，迭代器还有元素可以迭代时调用finishToArray
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//0x7fffffff-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不能过大，否则赋新值
                    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;
    }

    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) {//可以移除null元素
                    it.remove();
                    return true;
                }
            }
        } else {
            while (it.hasNext()) {
                if (o.equals(it.next())) {//equals
                    it.remove();
                    return true;
                }
            }
        }
        return false;
    }
    public boolean containsAll(Collection<?> c) {//是否包含集合c
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }
    public boolean addAll(Collection<? extends E> c) {//增加集合c，c要求是E的子孙类
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }
    public boolean removeAll(Collection<?> c) {//移除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) {//移除不为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() {//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(' ');
        }
    }

}