一、增强for循环

1. 三种常用for循环

// 普通for循环遍历
for (int i = 0; i < list.size(); i++) {
   System.out.print(list.get(i) + ",");
}
// 迭代器循环遍历
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
   System.out.print(iterator.next() + ",");
}
// 增强for循环
for (Integer i : list) {
   System.out.print(i + ",");
}

2. 增强for循环实现原理

编译前：

for (Integer i : list) {
   System.out.print(i + ",");
}

编译后：

Integer i;
for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(i)){
   i = (Integer)iterator.next();        
}

源码解析：

Integer i; // 定义一个临时变量i
Iterator iterator = list.iterator(); // 获取List的迭代器
iterator.hasNext(); // 判断迭代器中是否有未遍历过的元素
i = (Integer)iterator.next(); // 获取第一个未遍历的元素，赋值给临时变量i
System.out.println(i) // 输出临时变量i的值

通过反编译源码，我们看到，其实JAVA中的增强for循环底层是通过迭代器模式来实现的。

所以以下的代码：

Iterator<Map.Entry<String, Integer>> entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry<String, Integer> entry = entries.next();
    String key = entry.getKey();
    Integer value = entry.getValue();
}

 可以简化为：

for(Map.Entry<String, Integer> entry : myMap.entrySet()) {
    String qingActivityId = entry.getKey();
    Integer value = entry.getValue();
}

 

3. 注意：增强for循环可能遇到的坑

既然增强for循环通过迭代器实现，那么必然有迭代器的特性。

Java中有fail-fast机制。在使用迭代器遍历元素的时候，在对集合进行删除的时候一定要注意，使用不当有可能发生ConcurrentModificationException，这是一种运行时异常，编译期并不会发生。只有在程序真正运行时才会爆发。

// 代码示例
for (UserInfo user : userInfos) {    
   if (user.getId() == 2)     
      userInfos.remove(user);    
}

 会抛出ConcurrentModificationException异常。


Iterator是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出

java.util.ConcurrentModificationException异常。


所以 Iterator 在执行的时候是不允许被迭代的对象被改变的。

删除对象的正确做法：

你可以使用 Iterator 本身的方法 remove() 来删除对象，Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

正确的在遍历的同时删除元素的示例：

Iterator<UserInfo> userIterator = users.iterator();    
while (userIterator.hasNext()) {    
   UserInfo userInfo = userIterator.next();    
   if (userInfo.getId() == 2)    
       userIterator.remove();//这里要使用Iterator的remove方法移除当前对象，如果使用List的remove方法，则同样会出现ConcurrentModificationException    
}

 

二、for循环实战性能优化

循环结构让我们操作数组、集合和其他一些有规律的事物变得更加的方便，但是如果我们在实际开发当中运用不合理，可能会给程序的性能带来很大的影响。所以我们还是需要掌握一些技巧来优化我们的代码的。

1. 嵌套循环

1.1 代码示例

优化前代码示例

Long stratTime = System.nanoTime();  
for (int i = 0; i < 10000; i++) {  
    for (int j = 0; j < 10; j++) {  
          
    }  
}  
Long endTime = System.nanoTime();  
System.out.println("外大内小耗时："+ (endTime - stratTime));   

优化后代码示例

Long  stratTime = System.nanoTime();  
for (int i = 0; i <10 ; i++) {  
    for (int j = 0; j < 10000; j++) {  
          
    }  
}  
Long  endTime = System.nanoTime();  
System.out.println("外小内大耗时："+(endTime - stratTime));  

运行结果：

外大内小耗时：1957590
外小内大耗时：1228223

由运行结果来看采用外大内小的方式性能差距还是比较大的。

1.2 原理


如果遇到分支结构，就可以利用分支目标缓冲器预测并读取指令的目标地址。分支目标缓冲器在程序运行时将动态记录和调整转移指令的目标地址，可以记录多个地址，对其进行表格化管理。当发生转移时，如果分支目标缓冲器中有记录，下一条指令在取指令阶段就会将其作为目标地址。如果记录地址等于实际目标地址，则并行成功；如果记录地址不等于实际目标地址，则流水线被冲洗。同一个分支，多次预测失败，则更新记录的目标地址。因此，分支预测属于“经验主义”或“机会主义”，会存在一定误测。

————摘抄来源<<C++反汇编与逆向分析技术解密>> 4.4.2 分支优化规则


1.3 原理解析

// 外小内大
for (int i = 0; i <10 ; i++) {  
    // 下面每次循环会预测成功9999次
    // 第1次没有预测，最后退出循环时预测失败1次
    // 这样的过程重复10次
    for (int j = 0; j < 10000; j++) {  
          a[i][j]++;
    }  
}  
// 外大内小
for (int i = 0; i < 10000; i++) {  
    // 下面每次循环会预测成功9次
    // 第1次没有预测，最后退出循环时预测失败1次
    // 这样的过程重复10000次
    for (int j = 0; j < 10; j++) {  
          a[i][j]++;
    }  
}  

2. 消除循环终止判断时的方法调用

2.1 代码示例

未优化前代码示例

Long stratTime = System.nanoTime();  
for (int i = 0; i < list.size(); i++) {  
      
}  
Long  endTime = System.nanoTime();  
System.out.println("未优化list耗时："+(endTime - stratTime));  

优化后代码示例

Long  stratTime = System.nanoTime();  
int size = list.size();  
for (int i = 0; i < size; i++) {  
      
}  
Long  endTime = System.nanoTime();  
System.out.println("优化list耗时："+(endTime - stratTime)); 

运行结果

未优化list耗时：27375  
优化list耗时：2444

2.2原理


list.size()每次循环都会被执行一次，这无疑会影响程序的性能，所以应该将其放到循环外面，用一个变量来代替，优化前后的对比也很明显。


3. 异常捕获

3.1 代码示例

优化前代码示例

Long stratTime = System.nanoTime();  
for (int i = 0; i < 10000000; i++) {  
    try {  
    } catch (Exception e) {  
    }  
}  
Long  endTime = System.nanoTime();  
System.out.println("在内部捕获异常耗时："+(endTime - stratTime));  

优化后代码示例

Long  stratTime = System.nanoTime();  
try {  
    for (int i = 0; i < 10000000; i++) {  
    }  
} catch (Exception e) {  
  
}  
Long  endTime = System.nanoTime();  
System.out.println("在外部捕获异常耗时："+(endTime - stratTime));  

运行结果

在内部捕获异常耗时：12150142  
在外部捕获异常耗时：1955  

3.2 总结


捕获异常是很耗资源的，所以不要讲try catch放到循环内部，优化后同样有好几个数量级的提升。


 

来源于：

https://www.jianshu.com/p/f7c82aa62439

IT实战联盟博客：http://blog.100boot.cn 

前言

循环就是让我们的程序重复地执行某些业务。在程序设计时，需要处理大量的重复动作，采用循环结构可以降低程序书写的长度和复杂度，可使复杂问题简单化，提高程序的可读性和执行速度。其中，for循环就是循环结构的一种，另外还有while循环和do-while循环语句。但是for循环是开发者最常用的开发方式。


一、增强for循环
1. 三种常用for循环
# 普通for循环遍历
for (int i = 0; i < list.size(); i++) {
   System.out.print(list.get(i) + ",");
}
#迭代器循环遍历
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
   System.out.print(iterator.next() + ",");
}
#增强for循环
for (Integer i : list) {
   System.out.print(i + ",");
}

2. 增强for循环实现原理
编译前
for (Integer i : list) {
   System.out.print(i + ",");
}

编译后
Integer i;
for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(i)){
   i = (Integer)iterator.next();        
}

源码解析
Integer i; 定义一个临时变量i
Iterator iterator = list.iterator(); 获取List的迭代器
iterator.hasNext(); 判断迭代器中是否有未遍历过的元素
i = (Integer)iterator.next(); 获取第一个未遍历的元素，赋值给临时变量i
System.out.println(i) 输出临时变量i的值

通过反编译源码，我们看到，其实JAVA中的增强for循环底层是通过迭代器模式来实现的。
####3. 注意：增强for循环可能遇到的坑

既然增强for循环通过迭代器实现，那么必然有迭代器的特性。
Java中有fail-fast机制。在使用迭代器遍历元素的时候，在对集合进行删除的时候一定要注意，使用不当有可能发生ConcurrentModificationException，这是一种运行时异常，编译期并不会发生。只有在程序真正运行时才会爆发。
#代码示例
for (UserInfo user : userInfos) {    
   if (user.getId() == 2)     
      userInfos.remove(user);    
}

会抛出ConcurrentModificationException异常。

Iterator是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出

java.util.ConcurrentModificationException异常。

所以 Iterator 在执行的时候是不允许被迭代的对象被改变的。
但你可以使用 Iterator 本身的方法 remove() 来删除对象，Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。
正确的在遍历的同时删除元素的示例：
Iterator<UserInfo> userIterator = users.iterator();    
while (userIterator.hasNext()) {    
   UserInfo userInfo = userIterator.next();    
   if (userInfo.getId() == 2)    
       userIterator.remove();//这里要使用Iterator的remove方法移除当前对象，如果使用List的remove方法，则同样会出现ConcurrentModificationException    
}

二、for循环实战性能优化
循环结构让我们操作数组、集合和其他一些有规律的事物变得更加的方便，但是如果我们在实际开发当中运用不合理，可能会给程序的性能带来很大的影响。所以我们还是需要掌握一些技巧来优化我们的代码的。
1. 嵌套循环
1.1 代码示例
优化前代码示例
Long stratTime = System.nanoTime();  
for (int i = 0; i < 10000; i++) {  
    for (int j = 0; j < 10; j++) {  
          
    }  
}  
Long endTime = System.nanoTime();  
System.out.println("外大内小耗时："+ (endTime - stratTime));        

优化后代码示例
Long  stratTime = System.nanoTime();  
for (int i = 0; i <10 ; i++) {  
    for (int j = 0; j < 10000; j++) {  
          
    }  
}  
Long  endTime = System.nanoTime();  
System.out.println("外小内大耗时："+(endTime - stratTime));   

运行结果：
外大内小耗时：1957590
外小内大耗时：1228223

由运行结果来看采用外大内小的方式性能差距还是比较大的。
1.2 原理

如果遇到分支结构，就可以利用分支目标缓冲器预测并读取指令的目标地址。分支目标缓冲器在程序运行时将动态记录和调整转移指令的目标地址，可以记录多个地址，对其进行表格化管理。当发生转移时，如果分支目标缓冲器中有记录，下一条指令在取指令阶段就会将其作为目标地址。如果记录地址等于实际目标地址，则并行成功；如果记录地址不等于实际目标地址，则流水线被冲洗。同一个分支，多次预测失败，则更新记录的目标地址。因此，分支预测属于“经验主义”或“机会主义”，会存在一定误测。

————摘抄来源<<C++反汇编与逆向分析技术解密>> 4.4.2 分支优化规则

1.3 原理解析
#外小内大
for (int i = 0; i <10 ; i++) {  
    #下面每次循环会预测成功9999次
    #第1次没有预测，最后退出循环时预测失败1次
    #这样的过程重复10次
    for (int j = 0; j < 10000; j++) {  
          a[i][j]++;
    }  
}  
#外大内小
for (int i = 0; i < 10000; i++) {  
    #下面每次循环会预测成功9次
    #第1次没有预测，最后退出循环时预测失败1次
    #这样的过程重复10000次
    for (int j = 0; j < 10; j++) {  
          a[i][j]++;
    }  
}  

2. 消除循环终止判断时的方法调用
2.1 代码示例
未优化前代码示例
Long stratTime = System.nanoTime();  
for (int i = 0; i < list.size(); i++) {  
      
}  
Long  endTime = System.nanoTime();  
System.out.println("未优化list耗时："+(endTime - stratTime));  

优化后代码示例
Long  stratTime = System.nanoTime();  
int size = list.size();  
for (int i = 0; i < size; i++) {  
      
}  
Long  endTime = System.nanoTime();  
System.out.println("优化list耗时："+(endTime - stratTime));  

运行结果
未优化list耗时：27375  
优化list耗时：2444  

2.2原理
list.size()每次循环都会被执行一次，这无疑会影响程序的性能，所以应该将其放到循环外面，用一个变量来代替，优化前后的对比也很明显。

3. 异常捕获
3.1 代码示例
优化前代码示例
Long stratTime = System.nanoTime();  
for (int i = 0; i < 10000000; i++) {  
    try {  
    } catch (Exception e) {  
    }  
}  
Long  endTime = System.nanoTime();  
System.out.println("在内部捕获异常耗时："+(endTime - stratTime));  

优化后代码示例
Long  stratTime = System.nanoTime();  
try {  
    for (int i = 0; i < 10000000; i++) {  
    }  
} catch (Exception e) {  
  
}  
Long  endTime = System.nanoTime();  
System.out.println("在外部捕获异常耗时："+(endTime - stratTime));  

运行结果
在内部捕获异常耗时：12150142  
在外部捕获异常耗时：1955  

3.2 总结
捕获异常是很耗资源的，所以不要讲try catch放到循环内部，优化后同样有好几个数量级的提升。
结尾
性能优化的内容有很多，代码优化只是其中一小部分，我们在日常开发中应养成良好的编码习惯。接下来会跟大家探讨更多关于性能优化的内容，希望大家积极交流指导。
关注我们
如果需要源码可以关注“IT实战联盟”公众号并留言（源码名称+邮箱），小萌看到后会联系作者发送到邮箱，也可以加入交流群和作者互撩哦~~~
IT实战联盟博客：http://blog.100boot.cn 

for-each循环是jdk1.5引入的新的语法功能。并不是所有东西都可以使用这个循环的。可以看下Iterable接口的注释，它说明了除了数组外，其他类想要使用for-each循环必须实现这个接口。这一点表明除了数组外的for-each可能底层是由迭代器实现的。
Iterable接口在1.8之前只有一个方法,Iterator<T> iterator()，此方法返回一个迭代器。由于更早出现的Collection接口中早就有了这个同样的方法，所以只需要让Collection接口继承Iterable接口，基于Collection的集合类就可以不做任何更改就使用for-each循环。
对于数组，因为数组不实现Iterable接口，它的for-each实现原理应该和Collection不一样。


下面就通过分析下不同方式编译后的字节码，简单研究下for-each的的底层原理。


一、数组的for-each

下面是的两个很简单的类，可以看出它们的功能是一样的。Java环境使用的是jdk1.8_111。
package iter;

public class TestArray {
    public static void main(String[] args) {
        //String[] a = {"a", "b", "c"};
        long[] a = {2L, 3L, 5L};
        for (long i : a) {
            System.err.println(i);
        }
    }
}
package iter;

public class TestArrayFor {
    public static void main(String[] args) {
        //String[] a = {"a", "b", "c"};
        long[] a = {2L, 3L, 5L};
        for (int i = 0, len = a.length; i < len; i++) {
            System.err.println(a[i]);
        }
    }
}
TestArray使用for-each，TestArrayFor使用传统for循环，使用long数组是为了字节码中好区分int/long。
用javap -c看下两个类的字节码操作，保存成了文本，具体情况如下。
Compiled from "TestArray.java"
public class iter.TestArray {
  public iter.TestArray();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: iconst_3
       1: newarray       long
       3: dup
       4: iconst_0
       5: ldc2_w        #16                 // long 2l
       8: lastore
       9: dup
      10: iconst_1
      11: ldc2_w        #18                 // long 3l
      14: lastore
      15: dup
      16: iconst_2
      17: ldc2_w        #20                 // long 5l
      20: lastore
      21: astore_1           /* 0-21行，创建long数组a，并保存在线程的当前栈帧的局部变量表的第1格*/
      22: aload_1            /* 读取保存在线程的当前栈帧的局部变量表的第1格的对象的引用，就是读取数组a */
      23: dup                /* 把a的引用复制一遍并且再放到栈顶 */
      24: astore        6    /* 把栈顶的数存在线程的当前栈帧的局部变量表的第6格，就是生成a的一个值复制品b并存储起来，暂时不知道为什么这里要复制一次，后面的数组都还是用a表示 */
      26: arraylength        /* 获取数组长度a.length */
      27: istore        5    /* 把数组长度存储在线程的当前栈帧的局部变量表的第5格，22-27隐式执行了int len = a.length */
      29: iconst_0           /* 读取数字0（这个就是普通的0）到栈中 */
      30: istore        4    /* 把数字0放在线程的当前栈帧的局部变量表的第4格，29-30隐式执行了int i = 0 */
      32: goto          51   /* 无条件跳转到51那个地方，开始循环的代码 */
      35: aload         6    /* 读取数组a */
      37: iload         4    /* 读取i */
      39: laload             /* 读取a[i] */
      40: lstore_2           /* 把a[i]存在线程的当前栈帧的局部变量表的第2格 */
      41: getstatic     #22                 // Field java/lang/System.err:Ljava/io/PrintStream; /* 获取类的static属性，就是System.err */
      44: lload_2            /* 读取存在线程的当前栈帧的局部变量表的第2格的数据，就是读取a[i] */
      45: invokevirtual #28                 // Method java/io/PrintStream.println:(J)V          /* 执行虚拟机方法，30-36就是执行System.err.println(a[i]) */
      48: iinc          4, 1 /* 将第4格的数字加1，就是执行i++ */
      51: iload         4    /* 读取i */
      53: iload         5    /* 读取a.length */
      55: if_icmplt     35   /* 如果i < len，跳到标记35的那个地方，不满足就往下 */
      58: return
}
Compiled from "TestArrayFor.java"
public class iter.TestArrayFor {
  public iter.TestArrayFor();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: iconst_3
       1: newarray       long
       3: dup
       4: iconst_0
       5: ldc2_w        #16                 // long 2l
       8: lastore
       9: dup
      10: iconst_1
      11: ldc2_w        #18                 // long 3l
      14: lastore
      15: dup
      16: iconst_2
      17: ldc2_w        #20                 // long 5l
      20: lastore
      21: astore_1           /* 0-21行，创建long数组a，并保存在线程的当前栈帧的局部变量表的第1格*/
      22: iconst_0           /* 读取数字0（这个就是普通的0）到栈中 */
      23: istore_2           /* 将栈顶的数字0保存在第二个，22-23就是执行int i = 0; */
      24: aload_1            /* 读取保存在线程的当前栈帧的局部变量表的第1格的对象的引用，就是读取数组a */
      25: arraylength        /* 获取数组长度a.length */
      26: istore_3           /* 把数组长度保存在线程的当前栈帧的局部变量表的第3格，24-26就是执行int len = a.length */
      27: goto          42   /* 无条件跳到标记42的那个地方，开始循环的代码 */
      30: getstatic     #22                 // Field java/lang/System.err:Ljava/io/PrintStream; /* 获取类的static属性，就是System.err */
      33: aload_1            /* 读取数组a */
      34: iload_2            /* 读取i */
      35: laload             /* 读取a[i] */
      36: invokevirtual #28                 // Method java/io/PrintStream.println:(J)V          /* 执行虚拟机方法，30-36就是执行System.err.println(a[i]) */
      39: iinc          2, 1 /* 将第2格的数字加1，就是执行i++ */
      42: iload_2            /* 读取i */
      43: iload_3            /* 读取len */
      44: if_icmplt     30   /* 如果i < len，跳到标记30的那个地方，不满足就往下 */
      47: return
}
本人对照下字节码指令表，简单翻译了以下，都写在上面，还算是比较清楚。/**/中的就是本人的注释，//开头的是字节码自带的信息，这些信息不能完全算是注释吧，可以算是对字节码中出现的常量的一种直白翻译，让你看得懂这些常量代表什么。
通过编译后的字节码可以看出，数组的for-each和普通的for循环底层原理是一样的，都是用的普通for循环的那一套。数组的for-each比普通for循环多一点点操作，理论上是要慢一点点，这个暂时也不知道是为什么。这也是语法糖的一些代价，语法越简单，反而越不好进行底层优化。不过这个慢一点那真是一点，在循环体比较复杂时，这个差距就更小了，所以基本上可以认为这两种方式效率一样。实际中根据自己的情况选择，如果需要显式使用下标，就用传统for循环，其他的都可以使用for-each循环。



二、Collection的for-each
还是先贴两段简单的对比的代码，代码逻辑一样。Java环境使用的是jdk1.8_111。
package iter;

import java.util.ArrayList;
import java.util.List;

public class TestFor {
    public static void main(String[] args) {
        List<String> listA = new ArrayList<String>();
        for(String str : listA) {
            System.err.println(str);
        }
    }
}
package iter;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TestIter {
    public static void main(String[] args) {
        List<String> listA = new ArrayList<String>();
        for (Iterator<String> iter = listA.iterator(); iter.hasNext();) {
            String s = iter.next();
            System.err.println(s);
        }
    }
}



TestFor是for-each循环，TestIter是使用迭代器循环。
还是跟数组的一样分析，贴下编译后的字节码。


Compiled from "TestFor.java"
public class iter.TestFor {
  public iter.TestFor();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #16                 // class java/util/ArrayList
       3: dup
       4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: invokeinterface #19,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
      14: astore_3
      15: goto          35
      18: aload_3
      19: invokeinterface #25,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
      24: checkcast     #31                 // class java/lang/String
      27: astore_2
      28: getstatic     #33                 // Field java/lang/System.err:Ljava/io/PrintStream;
      31: aload_2
      32: invokevirtual #39                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      35: aload_3
      36: invokeinterface #45,  1           // InterfaceMethod java/util/Iterator.hasNext:()Z
      41: ifne          18
      44: return
}
Compiled from "TestIter.java"
public class iter.TestIter {
  public iter.TestIter();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #16                 // class java/util/ArrayList
       3: dup
       4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: invokeinterface #19,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
      14: astore_2
      15: goto          35
      18: aload_2
      19: invokeinterface #25,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
      24: checkcast     #31                 // class java/lang/String
      27: astore_3
      28: getstatic     #33                 // Field java/lang/System.err:Ljava/io/PrintStream;
      31: aload_3
      32: invokevirtual #39                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      35: aload_2
      36: invokeinterface #45,  1           // InterfaceMethod java/util/Iterator.hasNext:()Z
      41: ifne          18
      44: return
}


这两段字节码中自带的注释很多，基本上看得懂，就不添加注释了。
两段字节码除了几个变量保存在线程的当前栈帧的局部变量表的索引（astore_n，这个n就是索引）不一样外，其余的都是一模一样的。不排除某次编译后连那几个索引值也一样，那就真一模一样了。字节码自带的注释都说了，Collection的for-each底层也是使用迭代器来实现的，两种方式可以说是完全等价的。


对于实现了RandomAccess接口的实现类，因为它们的随机访问操作的时间复杂度为O(1)，大多数情况使用传统for循环会比用迭代器循环（这里的迭代器也可以用for-each替换，上面说了它们底层整体是一样的）要快。至于这一点是为什么，可以看下ArrayList的源码。它的迭代器虽然也是通过下标直接访问elementData数组，但是迭代器多了很多方法调用以及其他的额外操作，现在很多编译器cpu也都会对传统for循环进行特别的优化，在这个层面十几个指令的差别就很大了，这些因素加在一起导致RandomAccess的迭代器比传统for循环要慢一些。对于ArrayList这种，在cpu密集型的应用中应该只使用传统for循环，在循环体执行时间比较长的应用中，传统for循环和迭代器循环的差别就很小了，这时候使用迭代器（for-each循环）也不会明显降低执行效率。


参考：
1、https://docs.oracle.com/javase/8/docs/technotes/guides/language/foreach.html
2、Java虚拟机规范（Java SE 8）


以上内容如有问题，烦请指出，谢谢！

从parallel到parallel for

parallel for指令和parallel指令是不同的。



parallel

parallel指令只是指明后面的代码块被并行执行，对共享下标的访问次序无法控制和预知：



#include<stdio.h>
#include<stdlib.h>
#include<omp.h>

int main(int argc,char *argv[])
{
    int i;
    int thrdCnt=strtol(argv[1],NULL,10);
#   pragma omp parallel num_threads(thrdCnt)
    for(i=0;i<6;i++)
        printf("我是%d\n",omp_get_thread_num());
    return 0;
}

多次输出



[lzh@hostlzh OpenMP]$ ./test2.o 2
我是0
我是0
我是0
我是0
我是0
我是0
我是1
[lzh@hostlzh OpenMP]$ ./test2.o 2
我是0
我是0
我是0
我是0
我是0
我是1
我是0
[lzh@hostlzh OpenMP]$ ./test2.o 2
我是0
我是0
我是0
我是0
我是0
我是0
我是1
我是1
我是1
我是1
我是1
我是1
[lzh@hostlzh OpenMP]$



parallel for

而parallel for指令能将合法的典型结构的for循环并行化，且在parallel for中循环变量的缺省作用域是私有的，线程之间不会相互影响：



#include<stdio.h>
#include<stdlib.h>
#include<omp.h>

int main(int argc,char *argv[])
{
    int i;
    int thrdCnt=strtol(argv[1],NULL,10);
#   pragma omp parallel for num_threads(thrdCnt)
    for(i=0;i<6;i++)
        printf("我是%d\n",omp_get_thread_num());
    return 0;
}

输出



[lzh@hostlzh OpenMP]$ ./test2.o 2
我是0
我是0
我是0
我是1
我是1
我是1
[lzh@hostlzh OpenMP]$

可见对for循环进行了块划分。

注意parallel for和parallel是完全不同的指令，parallel for指令后面直接跟随需要并行化的for，而不能像parallel那样修饰大括号扩起来的代码块。



能够被parallel for正确并行化的for循环

书上把这样的for循环称为典型的for循环。



for循环头的允许形式

for⎛⎝⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜⎜i=a;i<bi>bi<=bi>=b;i++++ii−−−−ii+=ki−=ki=i+ki=k+ii=i−k⎞⎠⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟⎟for(i=a;i<bi>bi<=bi>=b;i++++ii−−−−ii+=ki−=ki=i+ki=k+ii=i−k)
对for循环体的限制

循环次数必须由前面的for循环头本身确定，不能在循环体中做可能改变for循环次数判定的事情，如break和改变循环变量的值。



书上的例子

这个例子使用parallel for并行化求ππ值的一个for循环。

用reduction归约子句保护了加入总和的过程，当然这里使用critical子句也可以，但保护的机制截然不同。

用private子句为符号变量sign设定了私有作用域，以保证每个线程对这个变量都有自己的副本，防止在使用前又被其它线程赋值改变。

用if-else判断解除了使用sign=-sign改变符号变量时具有的循环依赖问题，即本次循环中使用了前面循环计算得到的结果。循环依赖在循环并行化中往往是有害的，因为并行化的程序往往不按照串行的时间线执行，依赖了其它迭代次的数据是错误的，或者有时候所依赖的数据还没有计算出来(如斐波那契数列)。

而对于循环变量i，因为在parallel for指令中，循环变量的缺省作用域是私有的，所以它已经受到保护。



#include<stdio.h>
#include<stdlib.h>
#include<omp.h>

int main(int argc,char *argv[])
{
    double sum=0.0;//归约变量,被reduction子句保护
    int i;//循环变量,被parallel for保护为私有
    double sign;//表示符号的变量,被private子句保护
    int thrdCnt=strtol(argv[1],NULL,10);
#   pragma omp parallel for \
    num_threads(thrdCnt) \
    reduction(+:sum) \
    private(sign)
    for(i=0;i<10000;i++)
    {
        //利用if-else判断对sign=-sign解除循环依赖
        if(i%2==0)
            sign=1.0;
        else
            sign=-1.0;
        //本质上是加到reduction子句为每个线程建立的私有变量上
        sum+=sign/(2*i+1);
    }
    printf("pi=%f\n",4*sum);//这个级数*4近似为pi
    return 0;
}

输出



[lzh@hostlzh OpenMP]$ !gcc
gcc -fopenmp -o test2.o test2.c
[lzh@hostlzh OpenMP]$ ./test2.o 5
pi=3.141493
[lzh@hostlzh OpenMP]$

私有作用域的变量在parallel和parallel for块刚开始时和结束后都是未指定的。