为什么阿里巴巴强制不要在foreach里执行删除操作

　　那天，小二去阿里面试，面试官老王一上来就甩给了他一道面试题：为什么阿里的 Java 开发手册里会强制不要在 foreach 里进行元素的删除操作？小二听完就面露喜色，因为两年前，也就是 2021 年，他在《Java 程序员进阶之路》专栏上的第 63 篇看到过这题。
　　PS：star 这种事，只能求，不求没效果，铁子们，《Java 程序员进阶之路》在 GitHub 上已经收获了 437 枚星标，小伙伴们赶紧去点点了，冲 500 star！
　　https://github.com/itwanger/toBeBetterJavaer
　　为了镇楼，先搬一段英文来解释一下 fail-fast。
　　In systems design, a fail-fast system is one which immediately reports at its interface any condition that is likely to indicate a failure. Fail-fast systems are usually designed to stop normal operation rather than attempt to continue a possibly flawed process. Such designs often check the system＂s state at several points in an operation, so any failures can be detected early. The responsibility of a fail-fast module is detecting errors, then letting the next-highest level of the system handle them.
　　这段话的大致意思就是，fail-fast 是一种通用的系统设计思想，一旦检测到可能会发生错误，就立马抛出异常，程序将不再往下执行。  public void test(Wanger wanger) {        if (wanger == null) {         throw new RuntimeException(＂wanger 不能为空＂);     }          System.out.println(wanger.toString()); }
　　一旦检测到 wanger 为 null，就立马抛出异常，让调用者来决定这种情况下该怎么处理，下一步  wanger.toString()  就不会执行了——避免更严重的错误出现。
　　很多时候，我们会把 fail-fast 归类为 Java 集合框架的一种错误检测机制，但其实 fail-fast 并不是 Java 集合框架特有的机制。
　　之所以我们把 fail-fast 放在集合框架篇里介绍，是因为问题比较容易再现。  List list = new ArrayList<>(); list.add(＂沉默王二＂); list.add(＂沉默王三＂); list.add(＂一个文章真特么有趣的程序员＂);  for (String str : list) {  if (＂沉默王二＂.equals(str)) {   list.remove(str);  } }  System.out.println(list);
　　这段代码看起来没有任何问题，但运行起来就报错了。
　　根据错误的堆栈信息，我们可以定位到 ArrayList 的第 901 行代码。  final void checkForComodification() {     if (modCount != expectedModCount)         throw new ConcurrentModificationException(); }
　　也就是说，remove 的时候触发执行了  checkForComodification  方法，该方法对 modCount 和 expectedModCount 进行了比较，发现两者不等，就抛出了 ConcurrentModificationException  异常。
　　为什么会执行  checkForComodification  方法呢？
　　是因为 for-each 本质上是个语法糖，底层是通过迭代器 Iterator 配合 while 循环实现的，来看一下反编译后的字节码。  List list = new ArrayList(); list.add(＂沉默王二＂); list.add(＂沉默王三＂); list.add(＂一个文章真特么有趣的程序员＂); Iterator var2 = list.iterator();  while(var2.hasNext()) {     String str = (String)var2.next();     if (＂沉默王二＂.equals(str)) {         list.remove(str);     } }  System.out.println(list);
　　来看一下 ArrayList 的 iterator 方法吧：  public Iterator iterator() {     return new Itr(); }
　　内部类 Itr 实现了 Iterator 接口。  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;         Object[] elementData = ArrayList.this.elementData;         if (i >= elementData.length)             throw new ConcurrentModificationException();         cursor = i + 1;         return (E) elementData[lastRet = i];     } }
　　也就是说  new Itr()  的时候 expectedModCount 被赋值为 modCount，而 modCount 是 List 的一个成员变量，表示集合被修改的次数。由于 list 此前执行了 3 次 add 方法。 add 方法调用 ensureCapacityInternal 方法  ensureCapacityInternal 方法调用 ensureExplicitCapacity 方法  ensureExplicitCapacity 方法中会执行  modCount++
　　所以 modCount 的值在经过三次 add 后为 3，于是  new Itr()  后 expectedModCount 的值也为 3。
　　执行第一次循环时，发现＂沉默王二＂等于 str，于是执行  list.remove(str) 。 remove 方法调用 fastRemove 方法  fastRemove 方法中会执行  modCount++  private void fastRemove(int index) {     modCount++;     int numMoved = size - index - 1;     if (numMoved > 0)         System.arraycopy(elementData, index+1, elementData, index,                          numMoved);     elementData[--size] = null; // clear to let GC do its work }
　　modCount 的值变成了 4。
　　执行第二次循环时，会执行 Itr 的 next 方法（ String str = (String) var3.next(); ），next 方法就会调用 checkForComodification  方法，此时 expectedModCount 为 3，modCount 为 4，就只好抛出 ConcurrentModificationException 异常了。
　　那其实在阿里巴巴的 Java 开发手册里也提到了，不要在 for-each 循环里进行元素的 remove/add 操作。remove 元素请使用 Iterator 方式。
　　那原因其实就是我们上面分析的这些，出于 fail-fast 保护机制。
　　那该如何正确地删除元素呢 ？
　　1）remove 后 break  List list = new ArrayList<>(); list.add(＂沉默王二＂); list.add(＂沉默王三＂); list.add(＂一个文章真特么有趣的程序员＂);  for (String str : list) {  if (＂沉默王二＂.equals(str)) {   list.remove(str);   break;  } }
　　break 后循环就不再遍历了，意味着 Iterator 的 next 方法不再执行了，也就意味着  checkForComodification  方法不再执行了，所以异常也就不会抛出了。
　　但是呢，当 List 中有重复元素要删除的时候，break 就不合适了。
　　2）for 循环  List list = new ArrayList<>(); list.add(＂沉默王二＂); list.add(＂沉默王三＂); list.add(＂一个文章真特么有趣的程序员＂); for (int i = 0, n = list.size(); i < n; i++) {  String str = list.get(i);  if (＂沉默王二＂.equals(str)) {   list.remove(str);  } }
　　for 循环虽然可以避开 fail-fast 保护机制，也就说 remove 元素后不再抛出异常；但是呢，这段程序在原则上是有问题的。为什么呢？
　　第一次循环的时候，i 为 0， list.size()  为 3，当执行完 remove 方法后，i 为 1，list.size()  却变成了 2，因为 list 的大小在 remove 后发生了变化，也就意味着＂沉默王三＂这个元素被跳过了。能明白吗？
　　remove 之前  list.get(1)  为＂沉默王三＂；但 remove 之后 list.get(1)  变成了＂一个文章真特么有趣的程序员＂，而 list.get(0)  变成了＂沉默王三＂。
　　3）使用 Iterator  List list = new ArrayList<>(); list.add(＂沉默王二＂); list.add(＂沉默王三＂); list.add(＂一个文章真特么有趣的程序员＂);  Iterator itr = list.iterator();  while (itr.hasNext()) {  String str = itr.next();  if (＂沉默王二＂.equals(str)) {   itr.remove();  } }
　　为什么使用 Iterator 的 remove 方法就可以避开 fail-fast 保护机制呢？看一下 remove 的源码就明白了。  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();     } }
　　删除完会执行  expectedModCount = modCount ，保证了 expectedModCount 与 modCount 的同步。
　　简单地总结一下，fail-fast 是一种保护机制，可以通过 for-each 循环删除集合的元素的方式验证这种保护机制。
　　那也就是说，for-each 本质上是一种语法糖，遍历集合时很方面，但并不适合拿来操作集合中的元素（增删）。  原文链接：https://mp.weixin.qq.com/s/QxV79Rbhv1Hua7pIR8zLJA
　　原作者：沉默王二