继承AbstractList实现只读的List（CountingIntegerList类）
本章例子来自java编程思想小节——17.2.3 使用Abstract类——其中的CountingIntegerList类。
import java.util.AbstractList;
public class CountingIntegerList extends AbstractList<Integer> {
private int size;
public CountingIntegerList(int size) {
this.size = size < 0 ? 0 : size;
}
public Integer get(int index) {//重写并实现
return index;
}
public int size() {//重写并实现
return this.size;
}
public static void main(String[] args) {
System.out.println(new CountingIntegerList(30));
}
}/* output:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
*///:~
查看输出发现，它居然能打印0-29出来，明明我们只是实现了get() & size()方法。在之前的继承AbstractSet的例子里面（例子代码里面的静态内部类EntrySet），继承AbstractSet时需要实现的有iterator() & size()方法，但这里继承AbstractList时只需要实现get() & size()方法就可以了。iterator()相比get()方法差别还是很大的，iterator()返回的迭代器可以移动，并且每次移动则通过next()方法取值，而get()方法则是直接按照索引取值。
在debug模式下进行追踪，发现System.out.println(new CountingIntegerList(30))会调用到AbstractCollection的toString()方法里面去，原来toString()方法已经在AbstractCollection里面就已经写好了（回忆一下AbstractList的类型声明：public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>）。
//AbstractCollection.java
public String toString() {
Iterator<E> it = iterator();//返回一个迭代器，用Iterator接口来接的
if (! it.hasNext())//如果迭代器刚开始就不能移动
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
E e = it.next();//此时已经判断过hasNext可以返回true了
sb.append(e == this ? "(this Collection)" : e);//加入StringBuilder
if (! it.hasNext())//如果hasNext可以返回false，那么退出该方法
return sb.append(']').toString();
sb.append(',').append(' ');//如果hasNext可以返回true，那么先提前加好逗号空格
}
}
看上面代码还不知道这个迭代器的实现在哪里，但后面的逻辑则是正常打印一个集合的逻辑：反正已经有了迭代器，那么通过hasNext()的返回值来决定要不要调用next()来取值出来，每次取完值都把值的字符串表示加在一个StringBuilder上。
但iterator()方法在AbstractCollection中并没有实现，当然我们的CountingIntegerList里面也没有去实现，所以它的实现只能在AbstractList里：
//AbstractList.java
public Iterator<E> iterator() {
return new Itr();//调用成员内部类的构造器
}
private class Itr implements Iterator<E> {
/**
* Index of element to be returned by subsequent call to next.
*/
int cursor = 0;//代表下一次调用next将会返回的元素索引
/**
* Index of element returned by most recent call to next or
* previous. Reset to -1 if this element is deleted by a call
* to remove.如果lastRet索引元素已经被删除，那么lastRet会置为-1
*/
int lastRet = -1;//代表上一次调用next或previous返回的元素索引
/**
* The modCount value that the iterator believes that the backing
* List should have. If this expectation is violated, the iterator
* has detected concurrent modification.
*/
int expectedModCount = modCount;//获得外部类list对象的modCount成员，代表被修改的次数
public boolean hasNext() {
return cursor != size();//调用了例子代码重写的size方法。size刚好为最大索引+1，所以等于size时应该返回false
}
public E next() {
checkForComodification();
try {
int i = cursor;//既然cursor是下一次next返回的元素索引，那么next里就使用这个索引
E next = get(i);//调用了例子代码重写的get方法。这句是可能抛出IndexOutOfBoundsException的，当然本文例子不会抛出
lastRet = i;//next执行后，cursor就会变成last return
cursor = i + 1;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet < 0)//如果自己已经remove过了，那么再次remove就会抛异常
throw new IllegalStateException();
checkForComodification();//如果别的线程也remove外部类list对象了，那么也会抛出异常
try {
AbstractList.this.remove(lastRet);//调用外部类对象的remove方法，但AbstractList里只是默认实现直接抛异常
if (lastRet < cursor)
cursor--;
lastRet = -1;//删除后就置lastRet为-1
expectedModCount = modCount;//再次获得外部类对象的modCount成员，因为remove后modCount会发生改变
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)//比较迭代器自己存的count，和外部类对象存的count
throw new ConcurrentModificationException();
}
}
发现原来有个成员内部类Itr已经实现了Iterator接口，并在iterator()方法返回return new Itr()，这样每个迭代器对象都会持有一个外部类list对象的引用，而且list对象和迭代器对象的关系是一对多的。
成员内部类Itr的类定义里调用了我们例子代码里重写的get() & size()方法，具体看注释。继承AbstractList时，其实还有些方法比如remove()/add()/set()方法都是有默认实现的，但默认实现都是直接抛出UnsupportedOperationException异常，这种就是集合框架里面的可选操作，所以说本文例子代码只是一个只读的List，因为所有可选操作我们根本没有去重写实现它，只实现了必要的get() & size()方法（这两个方法是抽象方法，所以必须实现）。
