很长一段时间我都有同样的问题。所以我测试了一段更简单的代码。

结论:对于此类病例，两组间无显著性差异。

外环箱

int intermediateResult;
for(int i=0; i < 1000; i++){
    intermediateResult = i+2;
    System.out.println(intermediateResult);
}

内环箱

for(int i=0; i < 1000; i++){
    int intermediateResult = i+2;
    System.out.println(intermediateResult);
}

我检查了IntelliJ的反编译器上的编译文件，对于这两种情况，我得到了相同的Test.class

for(int i = 0; i < 1000; ++i) {
    int intermediateResult = i + 2;
    System.out.println(intermediateResult);
}

我还使用这个答案中给出的方法对这两种情况的代码进行了反汇编。我将只展示与答案相关的部分

外环箱

Code:
  stack=2, locals=3, args_size=1
     0: iconst_0
     1: istore_2
     2: iload_2
     3: sipush        1000
     6: if_icmpge     26
     9: iload_2
    10: iconst_2
    11: iadd
    12: istore_1
    13: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
    16: iload_1
    17: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
    20: iinc          2, 1
    23: goto          2
    26: return
LocalVariableTable:
        Start  Length  Slot  Name   Signature
           13      13     1 intermediateResult   I
            2      24     2     i   I
            0      27     0  args   [Ljava/lang/String;

内环箱

Code:
      stack=2, locals=3, args_size=1
         0: iconst_0
         1: istore_1
         2: iload_1
         3: sipush        1000
         6: if_icmpge     26
         9: iload_1
        10: iconst_2
        11: iadd
        12: istore_2
        13: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        16: iload_2
        17: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
        20: iinc          1, 1
        23: goto          2
        26: return
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
           13       7     2 intermediateResult   I
            2      24     1     i   I
            0      27     0  args   [Ljava/lang/String;

如果您仔细注意，在LocalVariableTable中，只有分配给i和intermediateResult的Slot会根据它们的出现顺序进行交换。slot中的相同差异也反映在其他代码行中。

当前无额外操作 在这两种情况下，intermediateResult仍然是一个局部变量，因此访问时间没有差异。

奖金

编译器做了大量的优化，看看在这种情况下发生了什么。

零工作情况

for(int i=0; i < 1000; i++){
    int intermediateResult = i;
    System.out.println(intermediateResult);
}

零工作反编译

for(int i = 0; i < 1000; ++i) {
    System.out.println(i);
}

我一直认为，如果你在循环中声明变量，那么你就是在浪费内存。如果你有这样的东西:

for(;;) {
  Object o = new Object();
}

然后，不仅需要为每次迭代创建对象，还需要为每个对象分配一个新的引用。看起来，如果垃圾收集器很慢，那么就会有一堆需要清理的悬空引用。

然而，如果你有这样的情况:

Object o;
for(;;) {
  o = new Object();
}

然后，您只需创建一个引用，并每次为它分配一个新对象。当然，它可能需要更长的时间才能超出作用域，但这时只需要处理一个悬空引用。

我怀疑一些编译器可以将两者优化为相同的代码，但肯定不是全部。所以我觉得你还是选择前者比较好。使用后者的唯一原因是希望确保声明的变量仅在循环中使用。

A)比B).........更安全想象一下，如果你在循环中初始化结构而不是'int'或'float'然后呢?

就像

typedef struct loop_example{

JXTZ hi; // where JXTZ could be another type...say closed source lib 
         // you include in Makefile

}loop_example_struct;

//then....

int j = 0; // declare here or face c99 error if in loop - depends on compiler setting

for ( ;j++; )
{
   loop_example loop_object; // guess the result in memory heap?
}

您肯定会遇到内存泄漏的问题!因此，我认为“A”是更安全的赌注，而“B”是容易受到内存积累的影响，特别是工作在近源库中。你可以在Linux上使用“Valgrind”工具检查，特别是子工具“Helgrind”。

当我想在退出循环后查看变量的内容时，我使用(A)。它只与调试有关。当我希望代码更紧凑时，我使用(B)，因为它节省了一行代码。

即使我知道我的编译器足够聪明，我也不喜欢依赖它，而是使用a)变体。

b)变体对我来说只有当你迫切需要使intermediateResult在循环体之后不可用时才有意义。但我无法想象这种绝望的情况，无论如何....

编辑:Jon Skeet提出了一个非常好的观点，表明在循环中声明变量可以产生实际的语义差异。