AbstractCollection接口源码分析

package java.util;

public abstract class AbstractCollection<E> implements Collection<E> {//实现了collection接口
    
    protected AbstractCollection() {
    }

    // 查
	/*抽象方法，子类必须以自己的方式实现这两个方法,只读集合只要实现这两个方法就可以了*/
    public abstract Iterator<E> iterator();
    public abstract int size();

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

    public boolean contains(Object o) {//null没有equals方法
        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();
        }
		//比预期的多，扩容继续，刚好的话就返回r
        return it.hasNext() ? finishToArray(r, it) : r;
    }

    @SuppressWarnings("unchecked")
    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();
        }
        // 比预期的多，扩容继续，刚好的话就返回r
        return it.hasNext() ? finishToArray(r, it) : r;
    }

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

    @SuppressWarnings("unchecked")
    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        int i = r.length;
        while (it.hasNext()) {
            int cap = r.length;
            if (i == cap) {//判断一下是否需要扩容了
				//扩容一半加1
                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) // 溢出，要求的内存太大，最大值加一就会变负值
            throw new OutOfMemoryError
                ("Required array size too large");
				//如果传回来的调整容量比虚拟机允许的最大值还大，那就返回一个整数的最大值
				//所以最大还是能扩到整数最大值那么大的容量的，还是不太懂这里，留个疑问吧
				//以后学会了再补吧
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    //改
	//默认不支持添加单个元素,如果直接调用 add(E) 方法,会报错,如果子类是可添加的数据结构，需要自己实现 add(E) 方法
    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;
    }

	//这个方法移除的是c中含有的本集合的元素，实质是本集合与交集的差集
    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;
    }

    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();
			//当把自己加入到集合就会输出[(this Collection)]
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }

}