我一直想知道，在一般情况下，在循环之前声明一个丢弃的变量，而不是在循环内部重复，使任何(性能)差异? Java中的一个(非常无意义的)例子:
A)循环前声明:
double intermediateResult;
for(int i=0; i < 1000; i++){
intermediateResult = i;
System.out.println(intermediateResult);
}
B)声明(重复)内部循环:
for(int i=0; i < 1000; i++){
double intermediateResult = i;
System.out.println(intermediateResult);
}
哪个更好，a还是b?
我怀疑重复的变量声明(例b)在理论上会产生更多的开销，但编译器足够聪明，所以这无关紧要。例b的优点是更紧凑，并且将变量的作用域限制在使用它的地方。尽管如此，我还是倾向于根据示例a编写代码。
编辑:我对Java案例特别感兴趣。
当前回答
我认为这取决于编译器，很难给出一个一般的答案。
其他回答
很长一段时间我都有同样的问题。所以我测试了一段更简单的代码。
结论:对于此类病例，两组间无显著性差异。
外环箱
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);
}
我认为b是更好的结构。在a中，intermediateResult的最后一个值在循环结束后保留。
编辑: 这与值类型没有太大区别，但引用类型可能会有些重要。就我个人而言，我喜欢尽快解除对变量的引用以进行清理，b为你做了这件事，
作为一般规则，我将变量声明在最内部的可能范围内。如果你不在循环外使用intermediateResult，那么我会用B。
我把A和B的例子各运行了20次，循环了1亿次。(jvm - 1.5.0)
A:平均执行时间:0.074秒
B:平均执行时间:0.067秒
令我惊讶的是B稍微快一点。 尽管现在的计算机速度很快，但很难说你是否能准确地测量这一点。 我也会用A的方式来编码，但我想说这并不重要。
我一直认为，如果你在循环中声明变量，那么你就是在浪费内存。如果你有这样的东西:
for(;;) {
Object o = new Object();
}
然后，不仅需要为每次迭代创建对象，还需要为每个对象分配一个新的引用。看起来，如果垃圾收集器很慢，那么就会有一堆需要清理的悬空引用。
然而，如果你有这样的情况:
Object o;
for(;;) {
o = new Object();
}
然后，您只需创建一个引用，并每次为它分配一个新对象。当然，它可能需要更长的时间才能超出作用域，但这时只需要处理一个悬空引用。
