Java集合基础——Collection和AbstractCollection

• Collection和AbstractCollection是什么？
• Collection源码
• AbstractCollection源码
• • 构造函数
  • 获取大小和判空
  • 集合转换为数组
  • 获取迭代器及操作集合元素方法
  • toString方法

Collection：Iterable的子类接口，所有集合接口的父类接口

AbstractCollection：Collection实现类，为一些通用的方法提供实现，继承AbstractCollection实现自己的数据结构可少写一些代码

下面的空格将源码分类：获取集合大小和判空、集合转换为数组、对元素增-删-查-并集-清空、从Object继承的方法、从Iterable继承的方法、Java8新特性方法（暂不了解）

public interface Collection extends Iterable {

	int size();
	boolean isEmpty();

	Object[] toArray();
	 T[] toArray(T[] a);
	
	boolean add(E e);
	boolean addAll(Collection c);
	boolean remove(Object o);
	boolean removeAll(Collection c);
	boolean contains(Object o);
	boolean containsAll(Collection c);
	boolean retainAll(Collection c);
	void clear();
	
	boolean equals(Object o);
	int hashCode();
	
	Iterator iterator();
	@Override
    default Spliterator spliterator() {
        return Spliterators.spliterator(this, 0);
    }    
    
   default boolean removeIf(Predicate filter) {
    	Objects.requireNonNull(filter);
   	 	boolean removed = false;
   		final Iterator each = iterator();
    	while (each.hasNext()) {
       		 if (filter.test(each.next())) {
            	each.remove();
            	removed = true;
        	}
    	}
    	return removed;
	}
    default Stream stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    default Stream parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }

AbstractCollection实现了Collection部分通用方法，下面将源码分类：

为什么为protected？

protected AbstractCollection() {
 }

已从Collection继承size()，为什么要再写一个size()

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

public Object[] toArray() {
    Object[] r = new Object[size()];
    Iterator 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[] toArray(T[] a) {
    int size = size();
    T[] r = a.length >= size ? a :  ( T[] )java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);
    Iterator it = iterator();
    for (int i = 0; i < r.length; i++) {
        if (! it.hasNext()) { 
            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();
    }
    return it.hasNext() ? finishToArray(r, it) : r;
}

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

private static  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) 
        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 addAll(Collection c) {
    boolean modified = false;
    for (E e : c)
        if (add(e))
            modified = true;
    return modified;
}

public boolean remove(Object o) {
    Iterator 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 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 it = iterator();
    while (it.hasNext()) {
        if (!c.contains(it.next())) {
            it.remove();
            modified = true;
        }
    }
    return modified;
}

public boolean containsAll(Collection c) {
    for (Object e : c)
        if (!contains(e))
            return false;
    return true;
}
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 it = iterator();
    while (it.hasNext()) {
        if (!c.contains(it.next())) {
            it.remove();
            modified = true;
        }
    }
    return modified;
}

public void clear() {
    Iterator it = iterator();
    while (it.hasNext()) {
        it.next();
        it.remove();
    }
}

public String toString() {
    Iterator 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(' ');
    }
}