for-each循环,你真的了解它么？

你走不出安逸的圈子，永远不知道外面的世界有多精彩。

前言

相信大家肯定都看过阿里巴巴开发手册，而在阿里巴巴开发手册中明确的指出，不要再foreach循环里面进行元素的add和remove，如果你非要进行remove元素，那么请使用Iterator方式，如果存在并发，那么你一定要选择加锁。

foreach

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");

        for (String s : list) {
            if ("b".equalsIgnoreCase(s) || "c".equalsIgnoreCase(s)) {
                list.remove(s);
            }
        }
        System.out.println(JSONObject.toJSONString(list));
    }

输出结果：

Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
    at java.util.ArrayList$Itr.next(ArrayList.java:859)
    at list.Test03.main(Test03.java:23)

Process finished with exit code 1

异常原因

我们从异常信息入手，at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

异常信息中的909行也就是从这里开始的，大家肯定会想他在比较两个值 modCount 和expectedModCount,那么这两个变量是什么呢？

其实说白了，他们就是来表示修改次数的变量，其中modCount表示集合的修改次数，这其中包括了调用集合本身的add方法等修改方法时进行的修改和调用集合迭代器的修改方法进行的修改。而expectedModCount则是表示迭代器对集合进行修改的次数。

而 expectedModCount 是个什么鬼？从ArrayList 源码可知，这个变量是一个局部变量，也就是说每个方法内部都有expectedModCount 和 modCount 的判断机制，进一步来讲，这个变量就是 预期的修改次数，而这个判断机制，很多人都会直接告诉你说fail-fas机制，你说这个机制，但是很多人都知道，你想解释明白他，需要点功夫的，理解起来肯定更需要花点时间的。

先来看看反编译之后的代码，如下：

    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        Iterator var2 = list.iterator();

        while(true) {
            String s;
            do {
                if (!var2.hasNext()) {
                    System.out.println(JSONObject.toJSONString(list));
                    return;
                }

                s = (String)var2.next();
            } while(!"b".equalsIgnoreCase(s) && !"c".equalsIgnoreCase(s));

            list.remove(s);
        }
    }

看里面使用的也是迭代器，也就是说，其实 foreach 每次循环都调用了一次iterator的next()方法，这也是为什么我们从堆栈信息看到的原因。

foreach方式中调用的remove方法，是ArrayList内部的remove方法，会更新modCount属性

到此，你可能还想看看，ArrayList类中的remove方法

    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        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

        return oldValue;
    }

看到此方法中，有一个modCount++的操作，也就是说，modCount会一直更新变化。

也就是说 remove方法它只修改了modCount，并没有对expectedModCount做任何操作。

可以看出，迭代器调用的是 Iterator 类的 remove 方法，foreach调用的是 ArrayList类 的remove方法，这是唯一的区别

迭代器

为什么阿里巴巴的规范手册会这样子定义？

它为什么推荐我们使用 Iterator呢？

直接使用迭代器会修改expectedModCount，而我们使用foreach的时候，remove方法它只修改了modCount，并没有对expectedModCount做任何操作，而Iterator就不会这个样子。

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if ("b".equalsIgnoreCase(item) || "c".equalsIgnoreCase(item)) {
                iterator.remove();
            }
        }
        System.out.println("iterator:" + JSONObject.toJSONString(list));
    }

输出结果：

iterator:["a","d","e"]

Process finished with exit code 0

可以看出结果是正确的，下面我们来分析一下：

先来看看反编译之后的代码：

    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        Iterator iterator = list.iterator();

        while(true) {
            String item;
            do {
                if (!iterator.hasNext()) {
                    System.out.println("iterator:" + JSONObject.toJSONString(list));
                    return;
                }

                item = (String)iterator.next();
            } while(!"b".equalsIgnoreCase(item) && !"c".equalsIgnoreCase(item));

            iterator.remove();
        }
    }

主要观察remove()方法的实现，那么需要先看 ArrayList.class：

    public Iterator<E> iterator() {
        return new Itr();
    }

    /**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator<E> {
        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;
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();     //第一步

            try {
                ArrayList.this.remove(lastRet);   //第二步：调用list的remove方法
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;         //第三步：modCount是remove方法去维护更新，
                                                    //由于第一步中校验 modCount 和 expectedModCount 是否相当等
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

list.iterator() 返回的是一个 Itr 对象（ArrayList私有的实例内部类），执行 iterator.remove() 方法时：

第一步：调用 checkForComodification() 方法，作用：判断modCount 和 expectedModCount 是否相当；

第二步：也就是foreach方式中调用的remove方法，在ArrayList内部的remove方法，会更新modCount属性；

第三步：将更新后的modCount重新赋值给expectedModCount变量，相当于有一个更新操作，才通过了上边第一步的校验!

Java8的新特性

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");

        list.removeIf(item -> "b".equalsIgnoreCase(item) || "c".equalsIgnoreCase(item));
        System.out.println("iterator:" + JSONObject.toJSONString(list));
    }

总结

for-each循环不仅适用于遍历集合和数组，而且能让你遍历任何实现Iterator接口的对象；最最关键的是它还没有性能损失。而对数组或集合进行修改（添加删除操作），就要用迭代器循环。所以循环遍历所有数据的时候，能用它的时候还是选择它吧。