引言
Collection接口中定义了许多方法，而AbstractCollection抽象类则实现了这个接口，并提供了一些方法的默认实现。这样一来，就可以减少我们编写集合实现类时所需要实现的方法。当我们需要实现一个不可修改的集合时，只需要继承AbstractCollection抽象类，并实现iterator、size方法。
如果要
一、类定义
public abstract class AbstractCollection<E> implements Collection<E>
二、方法定义
（一）构造方法
protected AbstractCollection() {
}
给子类构造方法调用（通常是隐式调用）
（二）查询操作
（1）
public abstract Iterator<E> iterator();
返回集合的元素之上的一个迭代器
（2）
public abstract int size();
返回集合元素个数
（3）
public boolean isEmpty() {
return size() == 0;
}
判断集合是否为空
（4）
public boolean contains(Object o) {
Iterator<E> it = iterator();
if (o==null) {
while (it.hasNext())
if (it.next()==null)
return true;
} else {
while (it.hasNext())
if (o.equals(it.next()))
return true;
}
return false;
}
判断集合是否包含某个元素，有可能抛出ClassCastException、NullPointerException异常。
此方法是通过使用迭代器遍历集合的每一个元素，然后使用equals()方法分别判断它们是否与指定对象相等来实现的。因为Iterator的存在，这里才可以进行一致性封装，使得此方法适用于各种类型的集合。同时，也要注意到对象的比较是通过equals()方法，而且还调用了it.next()、it.hasNext()方法，这也是为什么实现集合类需要重写equals()方法以及Iterator的两个方法。
（5）
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();
}
//元素比从size()中获取的更多，就需要进一步调整数组大小
return it.hasNext() ? finishToArray(r, it) : r;
}
此方法返回一个包含集合所有元素的数组
其逻辑如下：
1）创建一个大小为集合元素数量的数组r；
2）通过迭代器遍历集合，将当前集合中的元素复制到数组中（复制的是引用，也就是说得到的数组元素指向的对象还是集合数组对应元素指向的相同，这点我在后面写了个demo展示一下）
3）如果集合元素比预期的少，则调用Arrays.copyOf()方法，仅复制赋完值的部分到新数组中，并返回新数组；
4）如果集合元素比预期的多，则调用finishToArray()方法生成新数组，并返回新数组
5）如果集合元素跟预期的一样多，就直接返回最初创建的数组r即可
之所以要这样做是因为在迭代过程中，集合可能增加或者删除元素（并发环境下），那么最终通过迭代器遍历到的元素个数就有可能不是原来的集合大小。这么一来，就可以保证一定的数据一致性了，关于数据一致性以及并发方面的内容，后面会针对性地进行讨论。
接下来分析finishToArray()方法
@SuppressWarnings("unchecked")
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);
}
其中，MAX_ARRAY_SIZE的定义如下
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
此方法的功能是扩容数组
其逻辑如下：
1）查看传进来的迭代器是否还有元素，如果有则对传进来的数组进行扩容：创建一个更大的数组，然后将原数组的内容复制到这个数组中。扩容方式是先确定扩容容量：采用新容量newCap = cap + cap/2 +1，也就是1.5倍扩容；当newCap超过最大容量MAX_ARRAY_SIZE时，使用hugeCapicity()方法重新设置新容量newCap。最后使用Arrays.copyOf()方法进行扩容。
2）扩容完成后，将迭代器中还剩的元素复制到新数组中。
3）重复以上两个步骤，不断把迭代器中的元素添加到数组中。循环过程中因为一次扩容可能不够，所以可能需要多次扩容。判断是否还需要扩容的关键是if语句，当下一个存放位置 i 不等于数组的容量cap时，说明前面扩容的数组还有空间存放新元素；反之，则说明数组空间用完了，需要进行再一次的扩容。
4）当迭代器的所有元素都复制完毕，返回新数组。返回的时候将数组容量缩减到和元素个数相同，也就是说，此时有可能还需要重新分配一个新容量小的数组实例。
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;
}
综上，我们可以看到toArray()方法里面的主要操作是Arrays.copyOf()方法，占运行时间最大的也是此方法。此外，通过此方法返回的数组虽然是与集合数组独立的一个数组实例，但是由于新数组的元素都是复制集合数组元素，而这些元素都是引用，指向具体的对象，因此，新数组的元素指向的对象与集合数组的元素指向的是同一个对象。当我们通过新数组修改某一个元素指向的对象时，集合数组的对应元素看到的对象也就发生了变化。
（6）
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()类似，同样也是返回一个包含列表所有元素的数组，只不过这里允许我们传入参数指定返回数组的运行时类型。其实现与toArray()方法类似，这里就不分析了。
注意：toArray()方法返回的是Object[]的数组，而且返回的数组无法强制转换为其他类型，比如String[]，因为在运行时会抛出类型转换异常ClassCastException。当我们需要指定返回数组的运行时类型，只能使用toArray(T[])方法。
（三）修改操作
（1）
public boolean add(E e) {
throw new UnsupportedOperationException();
}
添加一个元素到集合中，默认不支持添加操作（抛出异常）。
如果要实现一个不可修改的集合，只需要继承这个抽象类，重写iterator()、size()方法即可。并且通过iterator()方法返回的iterator需要实现hasNext()、next()方法。
如果要实现一个可以修改的集合，则除了上述操作，还需要重写add()方法，因为add()方法的默认实现是抛出异常。同时通过iterator()方法返回的iterator还必须实现remove()方法。
（2）
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;
}
remove()方法和contains()方法，也是通过Iterator实现的，用于删除集合中的指定元素。
我们可以看到里面通过Iterator遍历集合元素，找到对应的元素，并利用迭代器的remove()方法对其进行删除。这也就是为什么当我们用AbstractCollection实现一个可以修改的集合类时，需要重写通过iterator()方法返回的iterator中的remove()方法。
当迭代过程中没有找到指定元素时，则返回false，表示删除失败。
（四）批量操作
（1）
public boolean containsAll(Collection<?> c) {
for (Object e : c)
if (!contains(e))
return false;
return true;
}
判断集合是否包含指定集合中的所有元素。
通过遍历指定集合的所有元素，并调用contains()方法判断每个元素是否存在于集合中实现。
（2）
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e))
modified = true;
return modified;
}
添加指定集合中的所有元素到集合中
通过遍历指定集合的所有元素，并调用add()方法添加每个元素到集合中。
当我们的实现类没有重写add()方法，此处会抛出UnsupportedOperationException异常。
（3）
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;
}
删除集合中所有包含在指定集合中的元素
通过集合的迭代器遍历集合的每一个元素，并调用指定集合的contains()方法判断每个元素是否存在于指定集合中，如果存在，则利用集合的迭代器的remove()方法将其删除（实现类必须实现迭代器的remove()方法）。
（4）
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
boolean modified = false;
Iterator<E> it = iterator();
while (it.hasNext()) {
if (!c.contains(it.next())) {
it.remove();
modified = true;
}
}
return modified;
}
只保留集合中所有包含在指定集合中的元素
与上面过程相反
（5）
public void clear() {
Iterator<E> it = iterator();
while (it.hasNext()) {
it.next();
it.remove();
}
}
将集合的所有元素删除。同样，利用的还是迭代器的remove()方法。
（五）其他方法
public String toString() {
Iterator<E> 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(' ');
}
}
字符串转换方法，返回集合的字符串表达形式