// Iterators
/**
* Returns an iterator over the elements in this list in proper
* sequence. <p>
*
* This implementation returns a straightforward implementation of the
* iterator interface, relying on the backing list's <tt>size()</tt>,
* <tt>get(int)</tt>, and <tt>remove(int)</tt> methods.<p>
*
* Note that the iterator returned by this method will throw an
* <tt>UnsupportedOperationException</tt> in response to its
* <tt>remove</tt> method unless the list's <tt>remove(int)</tt> method is
* overridden.<p>
*
* This implementation can be made to throw runtime exceptions in the face
* of concurrent modification, as described in the specification for the
* (protected) <tt>modCount</tt> field.
*
* @return an iterator over the elements in this list in proper sequence.
*
* @see #modCount
*/
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;
/**
* 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.
*这个modCount值,迭代器相信支持列表应该有。如果这种期望是违反,迭代器已检测到并发改 *。就会报异常
*/
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public E next() {
checkForComodification();
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch(IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}