我一直想知道，在一般情况下，在循环之前声明一个丢弃的变量，而不是在循环内部重复，使任何(性能)差异? 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);
}
其他回答
很长一段时间我都有同样的问题。所以我测试了一段更简单的代码。
结论:对于此类病例，两组间无显著性差异。
外环箱
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);
}
我做了一个简单的测试:
int b;
for (int i = 0; i < 10; i++) {
b = i;
}
vs
for (int i = 0; i < 10; i++) {
int b = i;
}
我用gcc - 5.2.0编译了这些代码。然后我分解main () 这两个代码的结果是:
1º:
0x00000000004004b6 <+0>: push rbp
0x00000000004004b7 <+1>: mov rbp,rsp
0x00000000004004ba <+4>: mov DWORD PTR [rbp-0x4],0x0
0x00000000004004c1 <+11>: jmp 0x4004cd <main+23>
0x00000000004004c3 <+13>: mov eax,DWORD PTR [rbp-0x4]
0x00000000004004c6 <+16>: mov DWORD PTR [rbp-0x8],eax
0x00000000004004c9 <+19>: add DWORD PTR [rbp-0x4],0x1
0x00000000004004cd <+23>: cmp DWORD PTR [rbp-0x4],0x9
0x00000000004004d1 <+27>: jle 0x4004c3 <main+13>
0x00000000004004d3 <+29>: mov eax,0x0
0x00000000004004d8 <+34>: pop rbp
0x00000000004004d9 <+35>: ret
vs
2º
0x00000000004004b6 <+0>: push rbp
0x00000000004004b7 <+1>: mov rbp,rsp
0x00000000004004ba <+4>: mov DWORD PTR [rbp-0x4],0x0
0x00000000004004c1 <+11>: jmp 0x4004cd <main+23>
0x00000000004004c3 <+13>: mov eax,DWORD PTR [rbp-0x4]
0x00000000004004c6 <+16>: mov DWORD PTR [rbp-0x8],eax
0x00000000004004c9 <+19>: add DWORD PTR [rbp-0x4],0x1
0x00000000004004cd <+23>: cmp DWORD PTR [rbp-0x4],0x9
0x00000000004004d1 <+27>: jle 0x4004c3 <main+13>
0x00000000004004d3 <+29>: mov eax,0x0
0x00000000004004d8 <+34>: pop rbp
0x00000000004004d9 <+35>: ret
这是完全相同的asm结果。这两种编码的结果不是一样的吗?
这取决于语言和确切的用法。例如，在c# 1中，这没有什么区别。在c# 2中，如果局部变量是通过匿名方法(或c# 3中的lambda表达式)捕获的，则会产生非常显著的差异。
例子:
using System;
using System.Collections.Generic;
class Test
{
static void Main()
{
List<Action> actions = new List<Action>();
int outer;
for (int i=0; i < 10; i++)
{
outer = i;
int inner = i;
actions.Add(() => Console.WriteLine("Inner={0}, Outer={1}", inner, outer));
}
foreach (Action action in actions)
{
action();
}
}
}
输出:
Inner=0, Outer=9
Inner=1, Outer=9
Inner=2, Outer=9
Inner=3, Outer=9
Inner=4, Outer=9
Inner=5, Outer=9
Inner=6, Outer=9
Inner=7, Outer=9
Inner=8, Outer=9
Inner=9, Outer=9
不同之处在于，所有的操作都捕获相同的外部变量，但每个操作都有自己独立的内部变量。
一位同事更喜欢第一种形式，说这是一种优化，更喜欢重用声明。
我更喜欢第二种(试着说服我的同事!);-))，已读到:
它将变量的范围缩小到需要的地方，这是一件好事。 Java进行了足够的优化，在性能上没有显著差异。IIRC，也许第二种形式更快。
无论如何，它属于依赖于编译器和/或JVM质量的过早优化的类别。
我的做法如下:
如果变量类型为simple (int, double，…)我更喜欢变种b(里面的)。 原因:减少变量的范围。 如果变量的类型不简单(某种类或结构)，我更喜欢变量a(外部)。 原因:减少与医生的通话次数。
