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

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

外环箱

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);
}

我认为这取决于编译器，很难给出一个一般的答案。

哪个更好，a还是b?

从性能的角度来看，你必须衡量它。(在我看来，如果你能测量到差异，编译器不是很好)。

从维护的角度来看，b更好。在同一个地方声明和初始化变量，在尽可能窄的范围内。不要在声明和初始化之间留下空隙，不要污染不需要的名称空间。

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

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

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

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

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

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

从性能的角度来看，外部(要好得多)。

public static void outside() {
    double intermediateResult;
    for(int i=0; i < Integer.MAX_VALUE; i++){
        intermediateResult = i;
    }
}

public static void inside() {
    for(int i=0; i < Integer.MAX_VALUE; i++){
        double intermediateResult = i;
    }
}

两个函数我都执行了10亿次。 Outside()耗时65毫秒。Inside()耗时1.5秒。

这是VB.NET的一个陷阱。在这个例子中，Visual Basic的结果不会重新初始化变量:

For i as Integer = 1 to 100
    Dim j as Integer
    Console.WriteLine(j)
    j = i
Next

' Output: 0 1 2 3 4...

第一次输出0 (Visual Basic变量声明时有默认值!)，之后每次输出i。

如果你加上a = 0，你可能会得到你所期望的:

For i as Integer = 1 to 100
    Dim j as Integer = 0
    Console.WriteLine(j)
    j = i
Next

'Output: 0 0 0 0 0...