我们查看Collection接口的hierarchy时候，可以看到AbstractCollection<E>这样一个抽象类，它实现了Collection接口的部分方法，Collection集合系列的各个集合类都继承于该抽象类。我们来看看这个类：
public abstract class AbstractCollection<E> implements Collection<E> {
protected AbstractCollection() {
}
public abstract Iterator<E> iterator();
public abstract int size();
public boolean isEmpty() {
return size() == 0;
}
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;
}
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;
}
@SuppressWarnings("unchecked")
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;
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
@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);
}
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 boolean add(E e) {
throw new UnsupportedOperationException();
}
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;
}
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
for (E e : c)
if (add(e))
modified = true;
return modified;
}
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;
}
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;
}
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(' ');
}
}
}
从它的代码里我们可以看到，它有一个最大长度，是Integer的最大值减去8，至于为什么减8，是因为有些JVM会在数组里保存几个关键字符。我们再看这个contains方法，我很好奇的是，既然参数是Object类型，那么就包括了null，为什么判断的时候还要把null单独拿出来，这个疑问不知哪个大佬能给我解释一下。
再看toArray的不带参方法，new了一个和size（）方法表示的长度一样长的Object数组r，还弄了一个迭代器出来，然后用for来循环r数组的每一个下标，并在每一次循环中判断迭代器的hasNext()是否为false，如果为false则说明当前集合长度比r数组短，则用Array的copyOf()方法把r数组放到一个长度为i的数组里，这样就不浪费多余的空间了。最后判断如果hasNext()还为true，则说明当前集合长度比r数组长，就用finishToArray（）方法返回一个Object数组。至于为什么比较过和size（）的大小之后还有这种操作，上面注释有说明，是迭代的时候假如对元素有增删操作，会导致长度有变化。finishToArray(T[] r, Iterator<?> it)方法把数组r扩容之后往里面添加迭代器后续元素，可以看到hugeCapacity这个玩意，当数组长度超过Integer最大值减8的时候，就用Integer的最大值，这样数组的长度是不能超过2^31的，毕竟数组下标使用int数字表示的。带参的toArray方法差不多意思，是可以将集合转化成指定类型的数组。
add()方法会直接抛出异常，说明AbstractCollection是不允许添加元素的，那么一定是在具体实现类里实现的这个方法。至于其他的方法，看一下就明白了。
接着我们来看看public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>，这是list的抽象类，继承自AbstractCollection，实现List接口的部分方法。源码就不贴了，现在重点来看一下内部类Itr，这是一个迭代器的实现类。里面定义了三个变量：游标cursor、最近一次调用返回的索引lastRet和期望得到的修改次数expectedModCount。里面实现了迭代器的三个方法，注意next()和remove()方法里都调用了这么一个方法checkForComodification()，这个用来比较expectedModCount和modCount，如果不同就抛出异常ConcurrentModificationException，这个意思是如果在迭代操作的时候，如果有用非迭代器的操作对集合做了修改，那么就会抛出异常。对于modCount，我们可以在AbstractList的子类中看到，每次对集合做了操作，modCount就会加一。
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(11);
list.add(12);
list.add(13);
list.add(14);
list.add(15);
Iterator<Integer> itr = list.iterator();
while(itr.hasNext()) {
if(itr.next() == 13) {
itr.remove();
}
}
System.out.println(list);
}
在迭代的时候用迭代器的remove操作就不会报错，如果在增强for循环中，用了ArrayList自带的remove，就会报异常了。下面的内部类ListItr是一个ListIterator的实现类，可以往前往后迭代，还有多了几个方法，代码都很简单。subList()截取一段子序列，支持往前往后截取。下面还有个SubList类，里面有个往后截取一段子序列的方法，其他的起始都是用的父类的方法。