先来看出错代码：

/*需求：
遍历已有集合
如果在集合中发现存在字符串元素“world”
则在“world”后添加元素“javaee”
*/

List list = new ArrayList();
//多态的形式创建接口实现类对象
list.add("helllo");
list.add("java");
list.add("world");

//生成迭代器并判断有无world这个元素，如果有则向集合中添加“javaee”
Iterator it = list.iterator();
while(it.hasNext()){
    String s = it.next();
    if(s.equals("world")){
    list.add("javaee");
    }
}

System.out.println(list);
//抛出异常：ConcurrentModificationException

这段代码中我试图在迭代的过程中通过list(List实现类对象)调用add方法向集合中添加元素并进行输出，但编译器在输出阶段抛出异常并终止了程序运行。

错误信息如下：

下面开始分析问题并找到解决方案：

1. 在错误信息中找到异常名称，将异常名称到帮助文档查看抛出异常的原因：

2. 通过报错信息定位抛出异常的方法。

        错误信息中蓝色高亮的部分UseIterator.java:23表示的是抛出异常的方法所在行数，进一步跟进是ArrayList中的Itr内部类中调用的next方法出的问题，再进一步跟进是ArrayList中的next方法调用的checkForComodification抛出的异常。

3.源码分析(选中类名ctrl+b查看源码)

        抛出异常的代码如下：

List<String> list = new ArrayList<String>();//创建集合对象
Iterator<String> it = list.iterator();//创建迭代器实现类对象

String s = it.next();//抛出异常的代码

从上面的代码中可以看到万恶之源是这个List，所以，先要有一个List，为了看起来更简洁这里我只拿了用到的内容过来，其他在这个案例中没有用到的就暂时没有管，下面的源码也会像这样简洁的拿过来看。

public interface List<E> extends Collection<E> {
    Iterator<E> iterator();
    boolean add(E e);
}

因为list是以多态的形式创建的ArrayList对象，所以也把ArrayList拿过来看看。

public class ArrayList<E> extends AbstractList<E> implements List<E>{
    private class Itr implements Iterator<E> {
        int expectedModCount = modCount;
        /*
            expectedModCount:预期修改值
            modCount:实际修改值(继承自父类AbstractList)
        */

        @SuppressWarnings("unchecked")
        //异常初步定位在内部类Itr的next方法中
        public E next() { 
            checkForComodification();//异常根源checkForComodification()方法
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        //异常根源
        final void checkForComodification() {
            if (modCount != expectedModCount)
            //当预期修改值与实际修改值不同抛出异常
            throw new ConcurrentModificationException();
        }
    }
}

从定义中可以看到ArrayList继承了AbstractList<E>，Abstract也暂时先把定义拿过来，里面需要用到的内容后面进行完善。

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>();

  ArrayList的定义中可以看出，除了继承AbstractList<E>外，还实现了接口List<E>，所以ArrayList中应该要有add方法的实现，所以将add方法的实现也拿过来看看。

public class ArrayList<E> extends AbstractList<E> implements List<E>{
    //重写接口中的add方法
    public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
         return true;
     }

    private class Itr implements Iterator<E> {
        int expectedModCount = modCount;
        /*
            expectedModCount:预期修改值
            modCount:实际修改值(继承自父类AbstractList)
        */

        @SuppressWarnings("unchecked")
        //异常初步定位在内部类Itr的next方法中
        public E next() {
            checkForComodification();
            //异常根源checkForComodification()方法
            ...
        }

        //异常根源
        final void checkForComodification() {
            if (modCount != expectedModCount)
            //当预期修改值与实际修改值不同抛出该异常
            throw new ConcurrentModificationException();
        }
    }
}

其实到这一步基本上已经能看出来个大概了，Itr实现了List中的Iterator接口，而出错的代码中的it正是Iterator的实现类对象，这里的Itr就是这个实现类。

        Itr在实现next时调用了checkForComodification()方法将expectedModCount和modCount进行对比，如果两边不等就会抛出异常。那么现在要解决的就是expectedModCount和modCount是什么的问题了。

        在Itr中有一个将modCount的值赋值给expectedModCount的操作，其中expectedModCount是itr中的成员变量，但是在ArrayList和Itr中都没有modCount的声明，那就只能是一种可能：modCount继承自父类。所以现在可以完善AbstractList<E>的一部分了

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>{
    protected transient int modCount = 0;
    //实际修改值最初值为0
}

好了，到这里就破案了，最开始的时候expectedModCount和modCount的值都是0，但是在代码中我在迭代过程中通过list调用了一下add方法，但是在add方法中每add一次就会对modCount进行一次++，所以导致expectedModCount ！= modCount，最终抛出ConcurrentModificationException并发修改异常。

//ArrayList重写接口中的add方法
public boolean add(E e) {
    modCount++;
    //每次在集合中添加新的元素后实际修改值++
    add(e, elementData, size);
    return true;
}

既然现在找到了错误的源头，那就要想一个解决方案出来了，最终目的是查找是否有“world”这个元素，并向集合中添加元素。迭代器行不通就换一种方法进行迭代，例如for循环

for(int i = 0;i<list.size();++i){
        String s = list.get(i);//通过get获取元素
        if(s.equals("world")){
            list.add("javaee");
    }
}    

但是这里又有一个问题，通过get获取元素为什么就不会报错了？空口无凭还是来看看代码吧，前面已经分析过的部分就不在赘述了，直接拿过来搞里头：

public interface List<E> extends Collection<E> {
    boolean add(E e);
    E get(int index);
}
public class ArrayList<E> extends AbstractList<E>implements List<E>{

  //实现List接口中的get，add方法
  public E get(int index) {
     Objects.checkIndex(index, size);
     return elementData(index);
  }

  public boolean add(E e) {
      modCount++;
      add(e, elementData, size);
      return true;
   }
}

源码说明一切，可以看到ArrayList实现get方法时没有比较expectedModCount和modCount的操作，所以不管add中对modCount的值++多少次都没有影响。

下面再捋一下思路。

4. 总结

1. 编译器抛出运行时异常（ConcurrentModificationException）
2.  追溯异常出现的方法（Itr.next().checkForComodification()）
3.  跟进代码找出问题根源。
4. 找出解决方案：采用for循环调用list.get()的方式遍历集合则可以避开checkForComodification()中的if (modCount != expectedModCount)比较，此时再调用add向集合添加元素即可。

        其中跟进代码思路如下：

• 错误代码中通过list.iterator获取到元素迭代器，并通过循环调用next的方式实现遍历集合，当发现“world”时会执行add操作
• ArrayList实现List中的add方法时加入了modCount++的操作，所以当向集合中添加元素后，modCount的值会发生变化
• next方法调用了checkForComodification()方法，该方法中进行了if (modCount != expectedModCount)比较
• 因为上一循环进行了add操作此时modCount值已经发生变化，再次进行比较时modCount != expectedModCount，所以抛出异常 

         大概就这些，欢迎指正。