所有这些循环都是一样的，我只是想在发表我的观点之前展示一下。

首先，循环List的经典方法:

for (int i=0; i < strings.size(); i++) { /* do something using strings.get(i) */ }

其次，这是首选的方法，因为它更不容易出错(你有多少次做过“哎呀，在这些循环中循环中混合变量i和j”的事情?)

for (String s : strings) { /* do something using s */ }

第三，微优化for循环:

int size = strings.size();
for (int i = -1; ++i < size;) { /* do something using strings.get(i) */ }

现在真正的两美分:至少当我测试这些时，第三个是最快的，当计算每种类型的循环所花费的毫秒数时，其中一个简单的操作重复了数百万次——这是在Windows上使用Java 5和jre1.6u10，如果有人感兴趣的话。

While it at least seems to be so that the third one is the fastest, you really should ask yourself if you want to take the risk of implementing this peephole optimization everywhere in your looping code since from what I've seen, actual looping isn't usually the most time consuming part of any real program (or maybe I'm just working on the wrong field, who knows). And also like I mentioned in the pretext for the Java for-each loop (some refer to it as Iterator loop and others as for-in loop) you are less likely to hit that one particular stupid bug when using it. And before debating how this even can even be faster than the other ones, remember that javac doesn't optimize bytecode at all (well, nearly at all anyway), it just compiles it.

如果你喜欢微观优化，或者你的软件使用了很多递归循环，那么你可能会对第三种循环感兴趣。只需要记住，在更改for循环之前和之后，都要对软件进行良好的基准测试。

不幸的是，两者之间似乎存在差异。

如果查看这两种循环生成的字节代码，就会发现它们是不同的。

下面是来自Log4j源代码的一个示例。

在/log4j-api/src/main/java/org/apache/ loggging/ log4j/ markermanager .java中，我们有一个名为Log4jMarker的静态内部类，它定义了:

    /*
     * Called from add while synchronized.
     */
    private static boolean contains(final Marker parent, final Marker... localParents) {
        //noinspection ForLoopReplaceableByForEach
        for (final Marker marker : localParents) {
            if (marker == parent) {
                return true;
            }
        }
        return false;
    }

使用标准循环:

  private static boolean contains(org.apache.logging.log4j.Marker, org.apache.logging.log4j.Marker...);
    Code:
       0: iconst_0
       1: istore_2
       2: aload_1
       3: arraylength
       4: istore_3
       5: iload_2
       6: iload_3
       7: if_icmpge     29
      10: aload_1
      11: iload_2
      12: aaload
      13: astore        4
      15: aload         4
      17: aload_0
      18: if_acmpne     23
      21: iconst_1
      22: ireturn
      23: iinc          2, 1
      26: goto          5
      29: iconst_0
      30: ireturn

for - each:

  private static boolean contains(org.apache.logging.log4j.Marker, org.apache.logging.log4j.Marker...);
    Code:
       0: aload_1
       1: astore_2
       2: aload_2
       3: arraylength
       4: istore_3
       5: iconst_0
       6: istore        4
       8: iload         4
      10: iload_3
      11: if_icmpge     34
      14: aload_2
      15: iload         4
      17: aaload
      18: astore        5
      20: aload         5
      22: aload_0
      23: if_acmpne     28
      26: iconst_1
      27: ireturn
      28: iinc          4, 1
      31: goto          8
      34: iconst_0
      35: ireturn

那个神谕是怎么回事?

我在Windows 7上用Java 7和Java 8尝试过。

以下是Android开发团队对两者差异的简要分析:

https://www.youtube.com/watch?v=MZOf3pOAM6A

The result is that there is a difference, and in very restrained environments with very large lists it could be a noticeable difference. In their testing, the for each loop took twice as long. However, their testing was over an arraylist of 400,000 integers. The actual difference per element in the array was 6 microseconds. I haven't tested and they didn't say, but I would expect the difference to be slightly larger using objects rather than primitives, but even still unless you are building library code where you have no idea the scale of what you will be asked to iterate over, I think the difference is not worth stressing about.

唯一确定的方法是对其进行基准测试，甚至这也不像听起来那么简单。JIT编译器可以对代码做一些意想不到的事情。

即使使用像ArrayList或Vector这样的东西，其中“get”是一个简单的数组查找，第二个循环仍然有第一个循环没有的额外开销。我预计它会比第一次慢一点。

所有这些循环都是一样的，我只是想在发表我的观点之前展示一下。

首先，循环List的经典方法:

for (int i=0; i < strings.size(); i++) { /* do something using strings.get(i) */ }

其次，这是首选的方法，因为它更不容易出错(你有多少次做过“哎呀，在这些循环中循环中混合变量i和j”的事情?)

for (String s : strings) { /* do something using s */ }

第三，微优化for循环:

int size = strings.size();
for (int i = -1; ++i < size;) { /* do something using strings.get(i) */ }

现在真正的两美分:至少当我测试这些时，第三个是最快的，当计算每种类型的循环所花费的毫秒数时，其中一个简单的操作重复了数百万次——这是在Windows上使用Java 5和jre1.6u10，如果有人感兴趣的话。

While it at least seems to be so that the third one is the fastest, you really should ask yourself if you want to take the risk of implementing this peephole optimization everywhere in your looping code since from what I've seen, actual looping isn't usually the most time consuming part of any real program (or maybe I'm just working on the wrong field, who knows). And also like I mentioned in the pretext for the Java for-each loop (some refer to it as Iterator loop and others as for-in loop) you are less likely to hit that one particular stupid bug when using it. And before debating how this even can even be faster than the other ones, remember that javac doesn't optimize bytecode at all (well, nearly at all anyway), it just compiles it.

如果你喜欢微观优化，或者你的软件使用了很多递归循环，那么你可能会对第三种循环感兴趣。只需要记住，在更改for循环之前和之后，都要对软件进行良好的基准测试。