解析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()方法