JDK1.8集合类学习< AbstractCollection>

AbstractCollection这个抽象类是开发者基于Collection接口的基础上实现了很多功能。有时候具体的实现类并不想实现接口的所有方法，而如果继承AbstractCollection这个抽象类，只需要实现其抽象方法就行，这也是集合元素所必须的，其他的方法就可以选择性的进行重写。

抽象类AbstractCollection实现了Collection接口

public abstract class AbstractCollection<E> implements Collection<E> 

只有一个默认构造器

	protected AbstractCollection() {
    }

抽象方法

返回这个集合中包含元素的一个迭代器。此集合数组元素数量。

	public abstract Iterator<E> iterator();

    public abstract int size();

toArray方法

此实现返回一个数组，该数组包含此集合的迭代器返回的所有元素，以相同的顺序存储在数组的连续元素中，返回数组的长度等于迭代器返回的元素数，即使此集合的大小在迭代期间发生更改，也会返回正确的结果。

	public Object[] toArray() {
        //Estimate size of array; be prepared to see more or fewer elements
        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) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        //先判断给定的数组a和当前的元素数量，保证r的容量不小于size
        T[] r = a.length >= size ? a :
                  (T[])java.lang.reflect.Array
                  .newInstance(a.getClass().getComponentType(), size);
        Iterator<E> it = iterator();
		/*  
		 *  r.length是>=size的，此时集合中的元素可能因为并发减少
		 *  if it.hasNext()==false，
		 *  1)a=r，集合中没有元素了，否则不会被执行，此时返回空的a数组
		 *  2)a.length < i，即给定数组容量比集合剩余的元素的数量小，类似于
		 *  上面的toArray(),调用Arrays.copyOf(r, i)复制数组，
		 *  返回数组r，
		 *  3)else 即给定数组容量不小于集合剩余的元素的数量,
		 *  把r的元素复制到a,
		 *  a[i]即a[集合真实长度+1]为空，返回a
		 */
        for (int i = 0; i < r.length; i++) {
            if(!it.hasNext()){ // fewer elements than expected
                if (a == r) {
                    r[i] = null; // null-terminate
                } 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();
        }
        // more elements than expected
        return it.hasNext() ? finishToArray(r, it) : r;
    }

如果元素变多，第一次执行进行扩容并把元素拷贝到新容量的r

	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;
                // overflow-conscious code
                if (newCap - MAX_ARRAY_SIZE > 0)
                    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;
    }

此抽象类没有给出add和addAll方法的具体实现。需要实现类自行实现。

	public boolean add(E e) {
        throw new UnsupportedOperationException();
    }

	public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

containsAll和contains

	public boolean containsAll(Collection<?> c) {
        for (Object e : c)
            if (!contains(e))
                return false;
        return true;
    }

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

remove和removeAll和retainAll

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