解析java.util集合类源码(Collection和AbstractCollection篇)

本篇为对java.util包下的集合知识总结，从jdk中Collection接口到ArrayList实体类

从结构上来看

接口Collection

Collection是所有集合类的最上层接口，继承了Iterable接口便于迭代，接口中定义了许多方法都是集合的添加，删除，包含元素，清空，添加集合等等一些对集合的操作，抽象了几乎所有集合需要用到的方法，细节在实现类和抽象类详细说明。

抽象类AbstractCollection

AbstractCollection抽象类实现了Collection接口，基本上主要的方法中都使用的Iterator进行集合的遍历，Iterator的实现放在子类中，实现多态。

  public abstract Iterator<E> iterator();

  public abstract int size();

 将两个抽象方法放到子类的去实现，同时实现了一些可以在所有Collection集合中共有的方法

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

通过子类实现的size()的个数是否为0 ，判断当前集合是否为空

   public boolean contains(Object o) {
    Iterator<E> e = iterator();
    if (o==null) {
        while (e.hasNext())
        if (e.next()==null)
            return true;
    } else {
        while (e.hasNext())
        if (o.equals(e.next()))
            return true;
    }
    return false;
    }

通过迭代当前集合，判断集合中是否有o元素

ps:

1.  在ArrayList中实现Iterator的内部类Itr， e.hasNext()方法判断的是通过判断当前迭代个数是否达到了size()的值，从而判断能否迭代，而e.next()方法返回的是那个存在于集 合中的那个对象，是有可能为Null的，所有当o为null时，在collection中也有一个null的对象会返回true

2. 在o.equals(e.next())时，应当注意该类是否重写了equals方法，否则只有当引用值相等时才会返回true

 public Object[] toArray() {
        // Estimate size of array; be prepared to see more or fewer elements
	Object[] r = new Object[size()];    //新建一个size()大小的Object数组
        Iterator<E> it = iterator();  
	for (int i = 0; i < r.length; i++) {
	    if (! it.hasNext())	// 如果在遍历的时候集合中的元素减少了，
		return Arrays.copyOf(r, i);  //返回一个长度为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;  //获取原始数组的长度
        while (it.hasNext()) {
            int cap = r.length;  //添加元素后的数组长度
            if (i == cap) {  //迭代的第一次
                int newCap = ((cap / 2) + 1) * 3;  //重写数组长度
                if (newCap <= cap) { // integer overflow
		    if (cap == Integer.MAX_VALUE)  //超过int的最大值，抛异常
 			throw new OutOfMemoryError("Required array size too large");
		    newCap = Integer.MAX_VALUE;
		}
		r = Arrays.copyOf(r, newCap);  //重新分配数组
	     }
	    r[i++] = (T)it.next();  
        }
        // 长度过多，截取数组
        return (i == r.length) ? r : Arrays.copyOf(r, i);
    }

在toArray方法中，为何不直接将存储数据的数组返回?在ArrayList中数据使用一个Object数组作为存储数据池，可其他集合类中不一定有同样的存储方式，但所有的集合类中都实现Iterable接口，使用这个接口获取迭代器，对集合进行遍历，在AbstractCollection抽象类中用通用的迭代的方法，保证下层所有的实现类都可用。动态数组的核心代码分析不在Arrays.copyOf(r, i)不在这里详细分析。在循环过程中可能Iterator中的元素有增加、删除的改变，当元素减少时，数组循环未结束，但是Iterator的迭结束，这时候截取数组，但是元素增加时候，调用finifshToArray(T[] r,Iterator<?> it)在数组添加为遍历到的元素

    public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        T[] r = a.length >= size ? a :  //若传参的数组比集合中元素的个数多，将数组付给r，否则，分配一个新的大小为size 的数组
                  (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)  //新建的数组
		    return Arrays.copyOf(r, i);
		    r[i] = null; // 在末尾添加一个null的结束符
		return r;
	    }
	    r[i] = (T)it.next();
	}
	return it.hasNext() ? finishToArray(r, it) : r;
    }

toArray(T[] a)方法与toArray()方法相似，同是遍历集合放回数组，不同的是在这个方法中有一个带有长度和类型的数组

 

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

add方法中只抛出了一个UnsupportedOperationException异常，说明子类要使用此方法必须重写add方法，否则会报出不可执行的异常

 public boolean remove(Object o) {
	Iterator<E> e = iterator();
	if (o==null) {
	    while (e.hasNext()) {
		if (e.next()==null) {
		    e.remove();
		    return true;
		}
	    }
	} else {
	    while (e.hasNext()) {
		if (o.equals(e.next())) {
		    e.remove();
		    return true;
		}
	    }
	}
	return false;
    }

remove(Object o)方法中，主要Iterator中的remove()删除集合中元素

 public boolean containsAll(Collection<?> c) {
	Iterator<?> e = c.iterator();
	while (e.hasNext()) //迭代整个外部传参的Collection
	    if (!contains(e.next()))  //调用AbstractCollection中contains方法
		return false;
	return true;  //只有将整个外部的Collection都遍历，并且其中元素都存在此集合
    }

containsAll(Collection<?> c)方法中，也主要是使用Iterator和本类中contains方法，判断外部的Collection集合是否都在集合中

public boolean addAll(Collection<? extends E> c) {
	boolean modified = false;
	Iterator<? extends E> e = c.iterator();
	while (e.hasNext()) {
	    if (add(e.next()))  //add方法必须由子类实现
		modified = true;
	}
	return modified;
    }

addAll(Collection <? extends E> c)方法，调用子类实现的add方法，若有一个元素添加成功，就返回true

  public boolean removeAll(Collection<?> c) {
	boolean modified = false;
	Iterator<?> e = iterator();
	while (e.hasNext()) {
	    if (c.contains(e.next())) {  //先判断存在
		e.remove();  //若存在删除
		modified = true;
	    }
	}
	return modified;
    }

removeAll(Collection<?> c)和addAll方法相似，在删除前需要先进性判断

public boolean retainAll(Collection<?> c) {
	boolean modified = false;
	Iterator<E> e = iterator();
	while (e.hasNext()) {
	    if (!c.contains(e.next())) {
		e.remove();
		modified = true;
	    }
	}
	return modified;
    }

retainAll(Collection<?> c)方法删除集合中不在外部集合的元素

 public void clear() {
	Iterator<E> e = iterator();
	while (e.hasNext()) {
	    e.next();
	    e.remove();
	}
    }

clear()清空集合元素

public String toString() {
        Iterator<E> i = iterator();
	if (! i.hasNext())  //集合是空的
	    return "[]";

	StringBuilder sb = new StringBuilder();
	sb.append('[');
	for (;;) {
	    E e = i.next();
	    sb.append(e == this ? "(this Collection)" : e);
	    if (! i.hasNext())
		return sb.append(']').toString();
	    sb.append(", ");
	}
    }

重写toString()方法