在 AbstractCollection笼统类中要求子类必需实现两个方法
子类必需要实现 get(), size()假如子类想要能够修改元素，还需要重写 add(), set(), remove() 方法，否则会报抛UnsupportedOperationException
listIterator.next() 游标 都会后移一位，当 listIterator.next() == o 时（即找到我们需要的的元素），游标已经在 o 的后面，所以需要返回 游标的 previousIndex().获取指定对象最后一次出现的位置
L203 : 获取 ListIterator，此时游标在最后一位
之后向前遍历
一律/范围 删除元素：
传入由子类实现的 size()
获取 ListIterator 来进行迭代删除
与其余集合实现类不同，AbstractList 内部已经提供了 Iterator, ListIterator 迭代器的实现类，分别为 Itr, ListItr
private class Itr implements Iterator<E> { //游标 int cursor = 0; //上一次迭代到的元素的位置，每次使用完就会置为 -1 int lastRet = -1; //用来判断能否发生并发操作的标示，假如这两个值不一致，就会报错 int expectedModCount = modCount; public boolean hasNext() { return cursor != size(); } public E next() { //时刻检查能否有并发修改操作 checkForComodification(); try { int i = cursor; //调用 子类实现的 get() 方法获取元素 E next = get(i); //有迭代操作后就会记录上次迭代的位置 lastRet = i; cursor = i + 1; return next; } catch (IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); } } public void remove() { if (lastRet < 0) throw new IllegalStateException(); checkForComodification(); try { //调用需要子类实现的 remove()方法 AbstractList.this.remove(lastRet); if (lastRet < cursor) cursor--; //删除后 上次迭代的记录就会置为 -1 lastRet = -1; expectedModCount = modCount; } catch (IndexOutOfBoundsException e) { throw new ConcurrentModificationException(); } } //检查能否有并发修改 final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); }}可以看到 Itr 只是简单实现了 Iterator 的 next, remove 方法
//ListItr 是 Itr 的加强版private class ListItr extends Itr implements ListIterator<E> { //多了个指定游标位置的构造参数，怎样都不检查能否越界！ ListItr(int index) { cursor = index; } //除了一开始都有前面元素 public boolean hasPrevious() { return cursor != 0; } public E previous() { checkForComodification(); try { //获取游标前面一位元素 int i = cursor - 1; E previous = get(i); //为什么上次操作的位置是 游标当前位置呢？哦，看错了，游标也前移了 lastRet = cursor = i; return previous; } catch (IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); } } //下一个元素的位置就是当前游标所在位置 public int nextIndex() { return cursor; } public int previousIndex() { return cursor-1; } public void set(E e) { if (lastRet < 0) throw new IllegalStateException(); checkForComodification(); try { //子类得检查 lasRet 能否为 -1 AbstractList.this.set(lastRet, e); expectedModCount = modCount; } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } } public void add(E e) { checkForComodification(); try { int i = cursor; AbstractList.this.add(i, e); //又置为 -1 了 lastRet = -1; cursor = i + 1; expectedModCount = modCount; } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } }}在 Itr 基础上多了 向前 和 set 操作
在 subList 方法中我们发现在切分 子序列时会分为两类，RandomAccess or not
ArrayList, 它的数据结构使得 get(), set(), add()等方法的时间复杂度都是 O(1)LinkedList, 链表结构使得它不支持随机访问，只能顺序访问，因而在少量操作上性能略逊一筹通常在操作一个 List 对象时，通常会判断能否支持 随机访问，也就是能否为 RandomAccess 的实例，从而使用不同的算法
比方遍历，实现了 RandomAccess 的集合使用 get():
for (int i=0, n=list.size(); i < n; i++) list.get(i);比用迭代器更快：
for (Iterator i=list.iterator(); i.hasNext(); ) i.next();实现了 RandomAccess 接口的类有：
ArrayList, AttributeList, CopyOnWriteArrayList, Vector, Stack 等。
// AbstractList 的子类，表示父 List 的一部分class SubList<E> extends AbstractList<E> { private final AbstractList<E> l; private final int offset; private int size;//构造参数://list ：父 List//fromIndex : 从父 List 中开始的位置//toIndex : 在父 List 中哪里结束SubList(AbstractList<E> list, int fromIndex, int toIndex) { if (fromIndex < 0) throw new IndexOutOfBoundsException("fromIndex = " + fromIndex); if (toIndex > list.size()) throw new IndexOutOfBoundsException("toIndex = " + toIndex); if (fromIndex > toIndex) throw new IllegalArgumentException("fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")"); l = list; offset = fromIndex; size = toIndex - fromIndex; //和父类使用同一个 modCount this.modCount = l.modCount;}//使用父类的 set()public E set(int index, E element) { rangeCheck(index); checkForComodification(); return l.set(index+offset, element);}//使用父类的 get()public E get(int index) { rangeCheck(index); checkForComodification(); return l.get(index+offset);}//子 List 的大小public int size() { checkForComodification(); return size;}public void add(int index, E element) { rangeCheckForAdd(index); checkForComodification(); //根据子 List 开始的位置，加上偏移量，直接在父 List 上进行增加 l.add(index+offset, element); this.modCount = l.modCount; size++;}public E remove(int index) { rangeCheck(index); checkForComodification(); //根据子 List 开始的位置，加上偏移量，直接在父 List 上进行删除 E result = l.remove(index+offset); this.modCount = l.modCount; size--; return result;}protected void removeRange(int fromIndex, int toIndex) { checkForComodification(); //调用父类的 局部删除 l.removeRange(fromIndex+offset, toIndex+offset); this.modCount = l.modCount; size -= (toIndex-fromIndex);}public boolean addAll(Collection<? extends E> c) { return addAll(size, c);}public boolean addAll(int index, Collection<? extends E> c) { rangeCheckForAdd(index); int cSize = c.size(); if (cSize==0) return false; checkForComodification(); //还是使用的父类 addAll() l.addAll(offset+index, c); this.modCount = l.modCount; size += cSize; return true;}public Iterator<E> iterator() { return listIterator();}public ListIterator<E> listIterator(final int index) { checkForComodification(); rangeCheckForAdd(index); //创立一个 匿名内部 ListIterator，指向的还是 父类的 listIterator return new ListIterator<E>() { private final ListIterator<E> i = l.listIterator(index+offset); public boolean hasNext() { return nextIndex() < size; } public E next() { if (hasNext()) return i.next(); else throw new NoSuchElementException(); } public boolean hasPrevious() { return previousIndex() >= 0; } public E previous() { if (hasPrevious()) return i.previous(); else throw new NoSuchElementException(); } public int nextIndex() { return i.nextIndex() - offset; } public int previousIndex() { return i.previousIndex() - offset; } public void remove() { i.remove(); SubList.this.modCount = l.modCount; size--; } public void set(E e) { i.set(e); } public void add(E e) { i.add(e); SubList.this.modCount = l.modCount; size++; } };}public List<E> subList(int fromIndex, int toIndex) { return new SubList<>(this, fromIndex, toIndex);}private void rangeCheck(int index) { if (index < 0 || index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}private void rangeCheckForAdd(int index) { if (index < 0 || index > size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}private String outOfBoundsMsg(int index) { return "Index: "+index+", Size: "+size;}private void checkForComodification() { if (this.modCount != l.modCount) throw new ConcurrentModificationException();}}SubList 就是啃老族，尽管自立门户，等到要干活时，使用的都是父类的方法，父类的数据。
所以可以通过它来间接操作父 List
