集合体系1-Collection结构

1.体系通用父接口Collection<E>

集合表示一组被称为其 元素 的对象， 一些集合允许重复元素，而其他集合不允许。 有些被命令和其他无序。 JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和List 。 该界面通常用于传递集合，并在需要最大的通用性的情况下对其进行操作。

public interface Collection<E> extends Iterable<E>

	int size();
	boolean isEmpty();
	//集合中包含元素o,(o==null)?e==null:o.equals(o);如果指定的元素为空，并且此集合不允许空元素
	boolean contains(Object o);
	//返回一个迭代器对象,iterator在接口 Iterable<E> 
	Iterator<E> iterator();
	//返回一个包含此集合中所有元素的数组,是对集合中的元素进行的拷贝
	Object[] toArray();
	//将集合转数组，如果a可以存储集合中元素，则用a存储，否则创建一个新的
	//数组，这是功能就是`Object[] toArray()`一样
	<T> T[] toArray(T[] a);
	//添加元素
	boolean add(E e);
	//删除元素，
	boolean remove(Object o);
	//如果此集合包含指定 集合中的所有元素，则返回true。 
	boolean containsAll(Collection<?> c);
	//批量添加，传入的是Collection集合，集合元素必须是E的子类
	boolean addAll(Collection<? extends E> c);
	//删除指定集合中包含的所有此集合的元素（可选操作）。 此调用返回后，此集合将不包含与指定集合相同的元素。 
	boolean removeAll(Collection<?> c);
	//清空
	void clear();

在Collection中，定义了集合体系下所有实现类的基本操作，这些操作中，较为重要的方法是add(E e),remove(Object),iterator()等。这些方法在不同的子类上，基于数据结构的不同，会有着不同的实现，本次先整个的分析集合体系的框架。

2.抽象子类AbstractCollection<E>

这个抽象类是对父接口的通用实现，该类提供了Collection接口的骨架实现，以尽量减少实现此接口所需的工作量。 实现了一些依赖其他方法的通用实现，比如，通过iterator(),实现集合操作的remove(Object o),contains(Object o),toArray,直接粘贴源码分析。

public abstract class AbstractCollection<E> implements Collection<E> {
	
	/***        尚未实现的方法          ***/
	public abstract Iterator<E> iterator();

    public abstract int size();

	//如果想要集合实现修改的操作，则要完成add方法的重写
	public boolean add(E e) {
        throw new UnsupportedOperationException();
    }


	/***       骨架实现      ***/
	public boolean isEmpty() {
        return size() == 0;
    }
	//包含指定元素
	public boolean contains(Object o) {
		//获取迭代器对象
        Iterator<E> it = iterator();
        if (o==null) {//分别对o是null进行判断
            while (it.hasNext())
                if (it.next()==null)
                    return true;
        } else {
            while (it.hasNext())
                if (o.equals(it.next()))
                    return true;
        }
        return false;
    }
    
    //集合转数组，返回的数组的长度等于迭代器返回的元素数量，即使该迭代器的大小在迭代期间发生变化，如果
    //该迭代允许在迭代期间同时进行修改，则可能会发生这种情况。 size方法仅被称为优化提示; 
    //即使迭代器返回不同数量的元素，也会返回正确的结果。
    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()) // fewer elements than expected
            	//截取数组，返回的数组是元素的长度数组
                return Arrays.copyOf(r, i);
            r[i] = it.next();
        }
        //迭代器中含有更多的元素，返回更长的数组
        return it.hasNext() ? finishToArray(r, it) : r;
    }
    
    //对剩余元素进行拷贝，这个时候，返回的数组，已经不等于原数组
    private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
        int i = r.length;
        //it迭代器是方法传进来的是迭代到刚好大于待扩展数组的第一个元素
        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();
        }
        // 如果过大，则需要分割数组，大小是元素个数i
        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 <T> T[] toArray(T[] a) {
        // 逻辑和上面的差不多，这里多了个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()) { // 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();
        }
        // 超过数组的大小，进行重新分配
        return it.hasNext() ? finishToArray(r, it) : r;
    }
 //元素删除，调用的是迭代器的remove方法
 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;
    }

通过查看，可以看到，该类完成了大部分的方法重写，比较重要的是toArray()方法，里面涉及对数组的拷贝，扩容，截取，以及支持集合元素增长后，能够正确拷贝，要仔细看一下实现。如果只需要对集合进行查询方面的操作，则只需要试下iterator()方法即可，jdk文档中有详细介绍。如果要实现修改等操作，需要子类重写add(E e)方法。

3.已知子类

这些都是Collection体系下面的

AbstractCollection ， AbstractList ， AbstractQueue ， AbstractSequentialList ，
AbstractSet ， ArrayBlockingQueue ， ArrayDeque ， ArrayList ， AttributeList ，
BeanContextServicesSupport ， BeanContextSupport ， ConcurrentHashMap.KeySetView ，
ConcurrentLinkedDeque ， ConcurrentLinkedQueue ， ConcurrentSkipListSet ，
CopyOnWriteArrayList ， CopyOnWriteArraySet ， DelayQueue ， EnumSet ， HashSet ，
JobStateReasons ， LinkedBlockingDeque ， LinkedBlockingQueue ， LinkedHashSet ，
LinkedList ， LinkedTransferQueue ， PriorityBlockingQueue ， PriorityQueue ， RoleList ，
RoleUnresolvedList ， Stack ， SynchronousQueue ， TreeSet ， Vector