JDK 1.7源码阅读笔记（六）集合类之AbstractCollection

前言

　　（1）AbstractCollection类提供 Collection 接口的骨干实现，以最大限度地减少了实现此接口所需的工作。 AbstractSet，AbstractList，AbstractSequentialList,AbstractQueue直接继承于AbstractCollection，后面还会说它的四个子类。

　　（2）要实现一个不可修改的 collection，编程人员只需扩展此类，并提供 iterator 和 size 方法的实现。（iterator 方法返回的迭代器必须实现 hasNext 和 next。）
　　要实现可修改的 collection，编程人员必须另外重写此类的 add 方法（否则，会抛出 UnsupportedOperationException），iterator 方法返回的迭代器还必须另外实现其 remove 方法。

　　（4）按照 Collection 接口规范中的建议，编程人员通常应提供一个 void （无参数）和 Collection 构造方法。
　　此类中每个非抽象方法的文档详细描述了其实现。如果要实现的 collection 允许更有效的实现，则可以重写这些方法中的每个方法。　　

源码：

public abstract class AbstractCollection<E> implements Collection<E> {  
    protected AbstractCollection() {//每个实现该抽象类的，需要提供一个空的构造函数  
    }  

    public boolean add(E object) {
        throw new UnsupportedOperationException();
    }
    public abstract Iterator<E> iterator();//返回迭代器  
    public abstract int size();//容量大小  

    public boolean isEmpty() {//是否为空 
        return size() == 0;  
    }  

    public boolean contains(Object o) {//判断元素o是否在集合中  
        Iterator<E> it = iterator();//获得当前迭代器  
        if (o==null) {//o为null  
            while (it.hasNext())//通过迭代器迭代判断是否有null的元素  
                if (it.next()==null)  
                    return true;  
        } else {//元素不为null  
            while (it.hasNext())  
                if (o.equals(it.next()))//判断内容  
                    return true;  
        }  
        return false;  
    }  

    public Object[] toArray() {//返回集合内元素的数组形式  
        int size = size(), index = 0;
        Iterator<?> it = iterator();
        Object[] array = new Object[size];//按size申请数组空间 
        while (index < size) {
            array[index++] = it.next();
        }
        return array;
    }  
    //返回具体的数组元素，这里的a只是一个参考值  
    public <T> T[] toArray(T[] contents) {  
        int size = size(), index = 0;//获得集合大小 
         //判断集合大小和contents的大小，如果contents的大小足够大，则用contents来存储元素，
         //否则新生成一个数组，注意是用反射生成的，所以其元素类型能保证 
        if (size > contents.length) {
            Class<?> ct = contents.getClass().getComponentType();
            contents = (T[]) Array.newInstance(ct, size);
        }
        for (E entry : this) {
            contents[index++] = (T) entry;
        }
        if (index < contents.length) {
            contents[index] = null;
        }
        return contents;
    }  

    //删除元素，这里是通过迭代器的删除操作来删除元素  
    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;  
    }  
    //判断c中的所有元素是否在集合中  
    public boolean containsAll(Collection<?> c) {  
        for (Object e : c)//c继承了Iterable接口，可以用foreach方法  
            if (!contains(e))  
                return false;  
        return true;  
    }  
    //添加所有的元素到集合中
    public boolean addAll(Collection<? extends E> collection) {
        boolean result = false;
        Iterator<? extends E> it = collection.iterator();
        while (it.hasNext()) {
            if (add(it.next())) {
                result = true;
            }
        }
        return result;
    } 
    //执行集合的交集操作  
    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())) {//不包含在集合c中  
                it.remove();  
                modified = true;  
            }  
        }  
        return modified;  
    }  
    //执行clear操作  
    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(' ');  
        }  
    }  
}