你真的了解for循环遍历么
今天讲的for循环主要是针对Java语言的JDK1.8，在编程过程中或多或少的遇到过for循环遍历，比如：List、Set、Map等等集合容器，有时候碰到需要对集合容器数据进行相应的增删改操作的时候，都会纠结一番到底会不会出现修改问题呢，如何遍历会更好呢。
等看完这篇你会觉得真的不一样了。
日常遍历的几种方式
首先我们先了解一下集合容器中日常遍历的几种方式：
List集合遍历方式（ArrayList）
// 遍历list集合 private static void listTest() { List<String> list = new ArrayList<String>(); list.add("liubei"); list.add("guanyu"); list.add("zhangfei"); // 使用传统for循环进行遍历 for (int i = 0, size = list.size(); i < size; i++) { String value = list.get(i); System.out.println(value); } // 使用增强for循环进行遍历 与iterator迭代器一致 for (String value : list) { System.out.println(value); } // 使用iterator遍历 Iterator<String> it = list.iterator(); while (it.hasNext()) { String value = it.next(); System.out.println(value); } //ArrayList 继承父类 Iterable 重写forEach 方法，进行相应校验判断，传统fori循环调用accept输出 list.forEach(new Consumer<String>() { @Override public void accept(String key) { System.out.println(key); } }); //Lambda 函数式Consumer list.forEach(key -> { System.err.println(key); }); }
Set集合遍历方式（HashSet）
private static void setTest() { Set<String> set = new HashSet<String>(); set.add("JAVA"); set.add("C"); set.add("C++"); // 使用iterator遍历set集合 Iterator<String> it = set.iterator(); while (it.hasNext()) { String value = it.next(); System.out.println(value); } // 使用增强for循环遍历set集合 字节码查看底层实际也是Iterator迭代器实现，与上面一样，写法区别而已 for (String s : set) { System.out.println(s); } //HashSet 继承父类 Iterable 直接调用父类forEach循环Consumer this 迭代器 循环accept方式 set.forEach(new Consumer<String>() { @Override public void accept(String key) { System.err.println(key); } }); //Lambda 函数式Consumer set.forEach(key -> { System.err.println(key); }); }
Map集合容器的遍历方式（HashMap）
public static void mapTest() { Map<String, String> maps = new HashMap<String, String>(); maps.put("1", "PHP"); maps.put("2", "Java"); maps.put("3", "C"); maps.put("4", "C++"); maps.put("5", "HTML"); Set<Map.Entry<String, String>> set = maps.entrySet(); //取key的增强遍历 实际 迭代器行为 Set<String> keySet = maps.keySet(); for (String s : keySet) { String key = s; String value = maps.get(s); System.out.println(key + " : " + value); } // 增强循环 实际 迭代器行为 for (Map.Entry<String, String> entry : set) { String key = entry.getKey(); String value = entry.getValue(); System.out.println(key + " : " + value); } // 迭代器遍历。 Iterator<Map.Entry<String, String>> it = set.iterator(); while (it.hasNext()) { Map.Entry<String, String> entry = (Map.Entry<String, String>) it.next(); String key = entry.getKey(); String value = entry.getValue(); System.out.println(key + " : " + value); } //HashMap 重写Map接口的forEach默认实现，进行相应的判断，传统fori遍历数组形式 maps.forEach(new BiConsumer<String, String>() { @Override public void accept(String key, String value) { System.err.println(key + " : " + value); } }); //Lambda 函数式Consumer maps.forEach((key,value)->{ System.err.println(key + " : " + value); }); }
遍历的问题
1、用那种遍历更好呢！
2、遍历的时候能操作（增删）集合信息么！
3、遍历中断、跳过怎么玩的！
每次撸代码的时候都会或多或少的思考一下这些问题，这也是基本工。
第一个问题：用那种遍历更好呢！
个人理解，主要还是要看业务中需要遍历的是什么类型的集合（数组），内部需要怎么操作，有时候就是需要获取根据下标位置进行业务逻辑处理，那就需要传统的for循环了。若是只是遍历进行key处理不涉及下标位置的，一般会选择foreach形式，比较简单快捷，其内部原理还是Iterator迭代器行为，Iterator一般不写主要原因比较麻烦复杂了点。
第二个问题：遍历的时候能操作（增删）集合信息么！
这个问题是本文中主要的部分，也是大多数人都会思考的问题，但是好像好多时候都理解错了。接下来我要颠覆认知的操作了。（也有可能是小丑）
在遍历增加删除的时候，首先大部分人都会想用那种遍历好，那种不会报错呢！报错的原因都以为是数组大小等问题，借着网上一堆解释糊弄了自己，结果一群人都被糊弄了。
举几个栗子：
ArrayList的传统的fori方式
应该都知道这个方式的增删没有问题吧
若是将传统for循环换成这样的，就会出现意想不到意思了--》【死循环】
出现以上问题的原因是，list的add每次添加的时候是都会将size增加【size++】，所有判断一直有效，死循环。remove的时候会对size递减【--size】，并不会出现null的出现，但是elementData数组大小是没变的，判断的是size。
说明在传统的for循环中，对集合的操作没有任何限制，只是写法问题会出现逻辑死循环。
ArrayList的foreach和Iterator方式
通过查看字节码信息了解到这两种方式其实是一样的原理
以下是上面的是字节码体现，可根据行号，对号入座，可以发现原理是一致的。
所有对这个的研究就直接针对迭代器就OK了，先看看ArrayList是否有对迭代器进行实现重写。一看还真有，对hasNext()、next()、remove()都进行了重写，在迭代器中没有元素的添加add行为，那我们来看看这些迭代器为啥有时候出问题有时候不会出问题。
其实关键这些都是围绕这modCount 属性做各种判断检查，主要意思是监控集合被修改的次数。
在ArrayList中使用迭代器遍历，迭代器在初始化的时候就将modCount属性赋值给迭代器自身的expectedModCount属性，需要仔细好好的看看源码，了解其中设计思想。
看看hasNext()，主要原理是看看cursor索引是否是到最后（size）了
public boolean hasNext() { return cursor != size; }
next()，主要原理是检查元素是否被修改、索引的大小、与内部数组大小的比较
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]; }
我们在看一下checkForComodification()方法就大概知道啥意思了
final void checkForComodification() { //检查集合的修改次数和迭代器预期的次数（初始化赋值那个）是否一致 if (modCount != expectedModCount) throw new ConcurrentModificationException(); }
最后看一下迭代器中的remove()方法，主要先检查是否有并发修改问题，然后利用ArrayList自身的remove()方法进行删除，修改modCount，并赋值给expectedModCount，差不多就是哪些俗称Fail-Fast以便下次checkForComodification()方法检查时不会出现问题。
public void remove() { // if (lastRet < 0) throw new IllegalStateException(); //检查是否被修改过 checkForComodification(); try { //调用ArrayList的自身的remove删除元素 ArrayList.this.remove(lastRet); //将索引值赋值为当前索引值，因为next的时候cursor++了 cursor = lastRet; //防止同一次遍历过程中删除两次 lastRet = -1; //将ArrayList中修改过的modCount 重新赋值给迭代器expectedModCount属性 expectedModCount = modCount; } catch (IndexOutOfBoundsException ex) { throw new ConcurrentModificationException(); } }
总结：从以上代码我们可以很容易的知道，在foreach和迭代器中删除元素时不会出现问题的，原因是ArrayList自身实现迭代器Iterator进行了一些逻辑处理，迭代器检查并调用ArrayList的删除方法，修改modCount的值，主要是modCount的灵活运用。但是对于添加元素add，迭代器中未做相关处理，所有会出现modCount的修改，并未同步给迭代器的expectedModCount属性，导致会出现同步修改问题ConcurrentModificationException。
ArrayList的foreach方法
应该知道集合循环有foreach方式底层原理是迭代器Iterator行为，但ArrayList中有一个foreach方法真实存在的，是实现Iterable重写foreach方法。
其实大部分的集合容器都有foreach方法，也比较实用，使用方式在上面ArrayList遍历方式中已经写过。
主要原理跟迭代器的remove有些类似，也是fail-fast行为策略，判断这个过程值modCount是否变化。
@Override public void forEach(Consumer<? super E> action) { Objects.requireNonNull(action); //将modCount值先保存一下 final int expectedModCount = modCount; @SuppressWarnings("unchecked") final E[] elementData = (E[]) this.elementData; final int size = this.size; //传统的for循环，每次循环还要判读modCount是否变化了 for (int i=0; modCount == expectedModCount && i < size; i++) { //业务逻辑点 action.accept(elementData[i]); } //判断这个过程中modCount是否变化了 if (modCount != expectedModCount) { //变化，则抛出异常 throw new ConcurrentModificationException(); } }
ArrayList使用Lambda的foreach函数方式
先说一下Lambda的实现原理
- 在类编译时，动态生成会生成一个私有静态方法+一个内部类；
- 在内部类中实现了函数式接口，在实现接口的方法中，会调用编译器生成的静态方法，这个静态方法与遍历对象的方法一致；
- 在使用lambda表达式的地方，通过传递内部类实例，来调用函数式接口方法。
参考地址：https://blog.csdn.net/jiankunking/article/details/79825928
从以上可以理解到，其实Lambda的函数式是根据集合方法实现个壳，内部还是调用了集合foreach方法进行遍历的，类似动态代理行为。
所以其原理和遍历策略是与集合ArrayList的内部foreach方法一致。
总结
1、以上只是针对ArrayList进行了深入分析，每个集合都有自己相对应的foreach方法和Iterator迭代器的实现，所以是否遍历有问题，遍历时的集合操作是否有问题，需要根据不同的集合类型进行不同的判断，而不是一味的理解操作的时候为foreach方法就是有问题，迭代器Iterator就是不会出现问题，传统for循环不好啥的，一定得有一股劲深入研究，才会拨开云雾。
2、还有好多栗子：如CopyOnWriteArrayList与ArrayList又有所不同，HashMap也不一样，每个都有自己的个性，可以查看源码，
3、这些都是对Collection或者Iterator进行相应的实现，其中差不多都是跟modCount有着千丝万缕的关系，又有着所谓的fail-fast机制。