foreach和iterator抉择问题？

今天在阿里巴巴java开发手册里看到一个强制规定原文如下：

【强制】不要在 foreach 循环里进行元素的 remove / add 操作。 remove 元素请使用 Iterator方式,如果并发操作,需要对 Iterator 对象加锁。

//反例
  List a = new ArrayList();
  a.add("1");
  a.add("2");
  for (String temp : a) {
      if("1".equals(temp)){
          a.remove(temp);
      }
  }

说明:以上代码的执行结果肯定会出乎大家的意料,那么试一下把“1”换成“2”,会是同样的
结果吗?

//正例
  Iterator it = a.iterator();
  while(it.hasNext()){
      String temp =  it.next();
      if(删除元素的条件){
        it.remove();
      }
  }

根据我的经验知道这个程序一定会抛java.util.ConcurrentModificationException异常,在我的这篇文章中提到过这个fail-fast（称为快速失败）对list的基础巩固。于是愉快的开始了验证。可气人的是这段代码居然运行通过。然后我把"1"换成"2"再运行，果断java.util.ConcurrentModificationException异常。那么问题来了，为啥"1"不报错呢？

我们先从foreach入手吧，我们都知道，foreach性能比for好，并且foreach写起来更加简洁，很多时候我们采用foreach遍历元素，而不采用for。可你想过foreach底层如何做的吗？

我们通过对这段代码的class文件进行反编译，结果如下：

  List a = new ArrayList();
  a.add("1");
  a.add("2");
  Iterator i$ = a.iterator();
  do
  {
      if(!i$.hasNext())
          break;
      String temp = (String)i$.next();
      if("1".equals(temp))
            a.remove(temp);
  } while(true);

foreach底层采用iterator对元素进行遍历。因为创建iterator的代价很小。接下来给大家带来jdk1.8的iterator源码分析。

public interface Iterator {

    boolean hasNext();

    E next();
   
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

前2个方法应该很熟悉，我们来看看iterator的实现（这里看arraylist的实现，其他类似。）

private class Itr implements Iterator {
        int cursor;                     // index of next element to return
        int lastRet = -1;            // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}

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

        @SuppressWarnings("unchecked")
        public E next() {
            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];
        }
        public void remove() {
              if (lastRet < 0)
                  throw new IllegalStateException();
              checkForComodification();

                try {
                    ArrayList.this.remove(lastRet);
                    cursor = lastRet;
                    lastRet = -1;
                    expectedModCount = modCount;      //注意这里
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
            }
        }
     ...省略了接口当中的forEachRemaining()方法.
    }

至于为何发生快速失败的的异常，在之前的文章中已经说过，就是modCount != expectedModCount导致，modCount是list被修改的次数，无论list.add()操作和list.remove()操作，modCount++，然而expectedModCount没有自动++;原因是expectedModCount是iterator的变量，而不是list的变量。只有调用iterator的remove()进行移除元素是，才会expectedModCount = modCount; 。所以在iterator中对list直接操作还是会发生问题的，删除元素，建议使用iterator的remove()的方法，可以看到，iterator好像没有add方法。我感觉add的场景也很少吧。

好了，接下来该聊聊为什么"1"的时候没有问题呢，通过上面的分析，我们知道，在操作了list之后，调用next()就会出现问题，因为操作list改变了modCount，而没有改变iterator的expectedModCount，于是调用next()方法时，报错。 "1"是怎么逃过的呢？

我测试了如下代码：

        List a = new ArrayList();
        a.add("1");
        a.add("2");
        a.add("3");

        Iterator iterator = a.iterator();
        while (iterator.hasNext()) {
            String  s = iterator.next();
            System.out.println(s);
            if("2".equals(s))
                a.remove(s);

        }

按这个规律我又测试了几组，发现只要是倒数第二个元素被操作，那么就不会发生问题。这是什么原因呢？我们来一步一步探索它。还是以这个程序为例：

        List a = new ArrayList();
        a.add("1");
        a.add("2");                                     //此时a的size = 2

        Iterator iterator = a.iterator();       // 此时iterator的cursor初始化为0
        while (iterator.hasNext()) {                    // size != cursor 返回true
            String  s = iterator.next();                // cursor = cursor + 1 = 1
            System.out.println(s);                            
            if("1".equals(s))
                a.remove(s);                            //size = size - 1 = 1,导致下一次循环的不执行，因为下一次循环判断cursor = size 。
        }

当add("1"),add("2")之后，a的 size = 2。a.iterator()之后执行完后，iterator的cursor = 0；第一次while， size ！= cursor ，返回true，程序允许执行，iterator.next() 这句代码执行后，cursor = cursor + 1 = 1， 然后执行a.remove(s) ，此时size = size - 1 = 1，来到第二次循环，发现cursor = size
，返回false，不执行下一次循环。如果执行了下一次循环，调用next()一定会报错。因为modCount ！= expectedModCount 。这下懂了吧，不报错是因为删除倒数第二个元素后少执行一次循环。当删除其他位置的元素时会多执行一次循环，而报错。这是就是cursor 和size的变化导致。

这里我们大部分可能关注这个异常为何发生，和如何解决。为了避免发生这种异常，必须从源头解决。那就是用iterator的remove()方法，不能因为偶然没有出错，而侥幸，给程序留下bug。

此篇文章告诉大家两个知识点，1 foreach 底层采用iterator实现。 2 不要在 foreach 循环里进行元素的 remove / add 操作。阿里巴巴java开发规范感觉不只是
讲规范，而且谈到很多注意的细节，那些是别人阿里团队开发java这么多年的经验。个人感觉受益良多。这里把它分享给大家 。

百度网盘 : https://pan.baidu.com/s/17YCdEChbqkekdRIAb8_wKQ 密码：w5qd