JDK源码解读————AbstractCollection（抽象类）

AbstractCollection注释的最上方，就说这是Collection基本的实现。

构造器方法

 protected AbstractCollection() {}

抽象方法

 public abstract Iterator<E> iterator();

 public abstract int size();

这里为什么这两个方法要定义成抽象的呢？其实原因很简单，因为容器实际的存储结构还没有确定下来，所以获取元素数量和迭代元素的方式也就无法确定。

非抽象方法

1.add(E e)新增一个对象

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

这里为什么不也定义成一个抽象方法呢？如果定义成抽象方法，那么子类就一定要实现这个方法；但是如果有好几个容器都不支持新增操作（我也不知道不能新增的容器能干啥。。。），那个实现这个方法的代码就重复了。

2.addAll(Collection<? extends E> c)

public boolean addAll(Collection<? extends E> c) {
    boolean modified = false;
    for (E e : c)
        if (add(e))
            modified = true;
    return modified;
}

3.remove(Object o)删除指定元素

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

看到这个方法有具体实现的时候，就会更加好奇add方法为什么只是抛出一个UnsupportedOperationException，其实个人感觉按照作者逻辑，这个方法应该跟add一样，但是因为iterator有remove方法，所以直接就调用了。

default void remove() {
    throw new UnsupportedOperationException("remove");
}

也就是说假如有一个继承这个类的子类A，没有覆写add方法以及iterator的remove方法，那么调用A.add和A.remove其实都是返回一个UnsupportedOperationException;

还有一个地方就是null的判断，完全可以写成下面这个三元表达式一样：

while(it.hasNext()){
    if( o==null? o==it.next():o.equals(it.next())){
        it.remove();
        return true;
    }
}

4.removeAll(Collection<?> c)

public boolean removeAll(Collection<?> c) {
    boolean modified = false;
    Iterator<?> it = iterator();
    //迭代器循环每个元素，如果集合c中含有这个元素，删除这个元素
    while (it.hasNext()) {
        if (c.contains(it.next())) {
            it.remove();
            modified = true;
        }
    }
    return modified;
}

5.retainAll(Collection<?> c) 求两个集合的交集

 public boolean retainAll(Collection<?> c) {
    boolean modified = false;
    Iterator<E> it = iterator();
    //迭代器循环每个元素，如果集合c中含有这个元素，删除这个元素
    while (it.hasNext()) {
        if (!c.contains(it.next())) {
            it.remove();
            modified = true;
        }
    }
    return modified;
}

这个方法跟removeAll基本上一模一样，就是if判断那里多了一个‘！’

6.clear()

public void clear() {
    Iterator<E> it = iterator();
    while (it.hasNext()) {
        it.next();
        //调用remove方法之前必须调用一下next
        it.remove();
    }
}

7.isEmpty判断是否为空（非抽象方法可以调用抽象方法）

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

8.contains() 是否包含某个元素

 public boolean contains(Object o) {
    //获取迭代器
    Iterator<E> it = iterator();
    if (o==null) {
        //容器元素可以是null
        while (it.hasNext())
            if (it.next()==null)
                return true;
    } else {
        //不是null的用equals方法来比较，如果对象没有实现equals方法，结果可能是错的。
        while (it.hasNext())
           if (o.equals(it.next()))
                return true;
    }
    return false;
}

一样可以改成三元表达式，另外这个不加大括号的代码确实不太好看

9.containsAll(Collection<?> c)

 public boolean containsAll(Collection<?> c) {
    for (Object e : c)
        //循环调用contains方法，只有一个不存在，则返回false
        if (!contains(e))
            return false;
    return true;
 }

10.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()) // fewer elements than expected
            return Arrays.copyOf(r, i);
        r[i] = it.next();
    }
    return it.hasNext() ? finishToArray(r, it) : r;
}

这个方法没有用iterator来迭代，而是用当前size()来新建一个object数组。注释的那行说的是，有可能元素会多，也有可能会少，为什么呢？单线程的情况下，肯定不存在上诉问题；但是如果是多线程的情况下，还没执行for循环的时候另一个线程对这个collection进行了新增操作，元素就多了；删除操作，元素就少了。

如果是删除操作： 假设一开始Collection里有4个元素，Object[]的长度就是4，然后for操作的时候变成了3个元素，那么当i==3的时候，触发if的条件，Arrays.copyOf(r,3)也就是返回一个只有3个元素的新数组，这样减少了空间的浪费；

如果是新增操作：假设上诉那个集合变成了5个元素，如果是用的iterator来迭代，循环到第5个元素的时候，数组空间已经用完了，就会报越界异常；按照上面代码的话，当for循环执行完了以后，执行return操作，it.hasNext会返回true，所以接着在执行finishToArray(r, it)方法。

12.finishToArray() 

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

按照toArray方法的分析，到这个方法里是因为数组的长度不够用了，所以最主要的操作就是给数组扩容。

int newCap = cap + (cap >> 1) + 1;

右移1位大概是cap的一半，但是如果cap是1的时候cap>>1==0,所以需要再+1来保证一定会扩容。

像我们举的例子：

第一遍循环：i是4，cap是4，那么newCap是7，r通过Arrays.copyOf扩容到7个元素，r[i++] = (T)it.next();填充数组的第4个元素（注意数组索引以0开始），i变为5；

第二遍循环：这时while循环条件不通过，执行最后return的语句，（5==7）不通过，所以Arrays.copyOf(r, 5) 返回一个5个元素的新数组。

13.toArray(T[] a)

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 :
                  (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();
        }
        // more elements than expected
        return it.hasNext() ? finishToArray(r, it) : r;
    }

这个方法实现跟toArray基本一致，只是在新建数组r的时候，是运用反射技术根据参数a的类型来新建一个相同类型的数组；r的初始长度跟参数a有关，也就是在上一篇文档Collection接口解析里最后提到的。