java集合--java.util.ConcurrentModificationException异常

package cn.itcast.p4.list.demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


public class ListIteratorException {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<String>list = new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        Iterator it = list.iterator();
        while(it.hasNext()){
            String s = (String) it.next();
            if(s.equals("abc2")){
                list.remove(s);
            }else{
                System.out.println(s);
            }
        }
        System.out.println(list);
    }

}

abc1
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.AbstractList$Itr.checkForComodification(AbstractList.java:372)
    at java.util.AbstractList$Itr.next(AbstractList.java:343)
    at cn.itcast.p4.list.demo.ListIteratorException.main(ListIteratorException.java:22)

    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.
        通过看API AbstractList.class 发现该类里面有一个成员变量： protected transient int modCount = 0;
        是不可被序列化的变量，当对集合进行add,remove,removeRange,addAll等修改动作的时候，没操作一次,modCount加1。
        用来记录对集合修改的次数。

     */
    int expectedModCount = modCount;//上面因为翻译过来，为迭代器的expectedModCount值和List集合中的modCount 初始值一致

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

    public E next() {
            checkForComodification();//每调用一次next方法，都要通过此方法检测expectedModCount（迭代对象的后）
        try {
        E next = get(cursor);
        lastRet = cursor++;
        return next;
        } catch (IndexOutOfBoundsException e) {
        checkForComodification();
        throw new NoSuchElementException();
        }
    }

    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();
        }
    }
    //用来检测现在的List中的modCount与创建迭代器的时候初始expectedModCount值是否想相等，不相等，返回异常ConcurrentModificationException
    final void checkForComodification() {
        if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    }
    }

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {

    protected transient int modCount = 0;
class SubList<E> extends AbstractList<E> {
  
。。。。。。。。省略很多代码。。。。。。。。。。。。。
 public void add(int index, E element) {
        if (index<0 || index>size)
            throw new IndexOutOfBoundsException();
        checkForComodification();
        l.add(index+offset, element);
        expectedModCount = l.modCount;
        size++;
        modCount++;
    }

    public E remove(int index) {
        rangeCheck(index);
        checkForComodification();
        E result = l.remove(index+offset);
        expectedModCount = l.modCount;
        size--;
        modCount++;
        return result;
    }

}
}