解析java.util集合类源码(AbstractList内部类ListIterator和Itr)

在AbstractList中用主要用Iterator和ListIterator来对列表进行遍历，但在AbstractList也没有声明一个Iterator对象，而是用一个内部类来实现这个功能。

首先在AbstractList中，有两个返回迭代器的方法

public ListIterator<E> listIterator()

public Iterator<E> iterator()

在iterator方法中

public Iterator<E> iterator() {
return new Itr();
}

返回了一个Itr类的对象，这是AbstractList中的内部类，实现了Iterator接口

AbstractList内部类Itr

/**
* Index of element to be returned by subsequent call to next.
*/
int cursor = 0;

/**
* 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.
*/
int lastRet = -1;

/**
* 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;

在Itr中有三个属性域

cursor 迭代时候标识当前将要遍历元素的下标

lastRet是列表中由next或者previous方法最后访问指向的下标

expectedModCount 这个属性最重要，在AbstractList中有modCount属性，这两个属性主要用来辨别在程序中，返回了Iterator迭代器之后，该列表是否又进行了修改(如添加、删除),当列表进行了这些操作之后，modCount会改变，但是expectedModCount没有变，当modCout!=expectedModCount报异常,像下面的代码

@Test
public void test(){

ArrayList list = new ArrayList();
list.add("ee");
list.add("ee");
list.add("eee");
Iterator it = list.listIterator();
list.add("在这里会修改modCount");
it.next(); //这会报错，原因modCount与expectedModCount值不同

}

也就是说当列表在进行迭代时候不允许列表添加(删除)等操作

public boolean hasNext() {
return cursor != size();
}

调用子类实现的size()方法，判断是否还有下一个元素

final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}

checkForComodification方法中判断modCount和expectedmodCount是否相等，不相等报异常，因为此类中的每个方法基本都要用这个方法，所以先写出来

public E next() {
checkForComodification();
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}

先调用checkForComodification检查，列表是否被修改了，调用子类实现get方法，给lstRet和cursor重新赋值

public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();

try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}

使用remove方法，必须先使用next方法，remove删除的是当前指向的那个对象，若还没有用next方法，使lastRet初始化，lastRet的值为-1抛出异常，然后检查列表修改

调用子类实现的remove方法移除对象，对lastRest和cursor重新赋值

AbstractList内部类ListItr

ListItr实现了ListIterator接口同时继承了Itr，此接口是Iterator接口的扩展，使迭代器不但可以向后遍历，也可以向前遍历,还可以获取将要遍历元素的下标，

和当前元素的下标，同时可以通过迭代器对元素进行添加、删除、修改的操作

public boolean hasPrevious() {
return cursor != 0;
}

通过判断cursor是否为0 ，来辨别在当前元素前是否还有元素可以遍历，当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;
}

返回当前将要遍历元素的下标  和   返回对 previous 的后续遍历所返回元素的下标

public void set(E e) {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();

try {
AbstractList.this.set(lastRet, e);
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}

对next或previous方法返回的最后一个元素进行替换

public void add(E e) {
checkForComodification();

try {
AbstractList.this.add(cursor++, e);
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}

将指定的元素插入列表到列表将要遍历的位置，同时将lastRet置-1，表明刚才的操作可能会使lastRet指向新插入的元素而不是原来指向的元素