为什么以下工作正常？
String str;
while (condition) {
str = calculateStr();
.....
}
但是据说这个是危险的/不正确的：
while (condition) {
String str = calculateStr();
.....
}
是否需要在循环外声明变量？
【问题讨论】：
标签： java optimization while-loop
在您的示例中，我假设 str 是 not 在 while 循环之外使用的，否则您不会问这个问题，因为在 while 循环内声明它不会是一个选项，因为它不会编译。
因此，由于str不在循环外使用，str 的最小可能范围是在 while 循环内。
所以，答案是强调str 绝对应该在while 循环中声明。没有如果，没有与，没有但是。
唯一可能违反此规则的情况是，如果出于某种原因，必须从代码中挤出每个时钟周期至关重要，在这种情况下，您可能需要考虑在外部范围内实例化某些内容并重用它而不是在内部范围的每次迭代中重新实例化它。但是，这不适用于您的示例，因为 java 中字符串的不变性：str 的新实例将始终在循环开始时创建，并且必须在循环结束时被丢弃，所以有那里不可能优化。
编辑：（在答案下方插入我的评论）
无论如何，正确的做事方式是正确编写所有代码，为产品建立性能要求，根据此要求衡量最终产品，如果不满足，则进行优化。通常最终会发生的事情是，您找到了在几个地方提供一些不错的正式算法优化的方法，这使我们的程序满足其性能要求，而不必遍历整个代码库并调整和破解。为了在这里和那里压缩时钟周期。
【讨论】：
我比较了这两个（相似）示例的字节码：
让我们看看1。示例：
package inside;
public class Test {
public static void main(String[] args) {
while(true){
String str = String.valueOf(System.currentTimeMillis());
System.out.println(str);
}
}
}
在javac Test.java、javap -c Test 之后，你会得到：
public class inside.Test extends java.lang.Object{
public inside.Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: invokestatic #2; //Method java/lang/System.currentTimeMillis:()J
3: invokestatic #3; //Method java/lang/String.valueOf:(J)Ljava/lang/String;
6: astore_1
7: getstatic #4; //Field java/lang/System.out:Ljava/io/PrintStream;
10: aload_1
11: invokevirtual #5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
14: goto 0
}
让我们看看2。示例：
package outside;
public class Test {
public static void main(String[] args) {
String str;
while(true){
str = String.valueOf(System.currentTimeMillis());
System.out.println(str);
}
}
}
在javac Test.java、javap -c Test 之后，你会得到：
public class outside.Test extends java.lang.Object{
public outside.Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: invokestatic #2; //Method java/lang/System.currentTimeMillis:()J
3: invokestatic #3; //Method java/lang/String.valueOf:(J)Ljava/lang/String;
6: astore_1
7: getstatic #4; //Field java/lang/System.out:Ljava/io/PrintStream;
10: aload_1
11: invokevirtual #5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
14: goto 0
}
观察表明，这两个示例之间没有区别。这是JVM规范的结果……
但以最佳编码实践的名义，建议在尽可能小的范围内声明变量（在本例中，它位于循环内，因为这是唯一使用变量的地方）。
【讨论】：
final 爱好者：在inside 包案例中将str 声明为final 也 没有区别=)
在最小范围中声明对象可以提高可读性。
对于当今的编译器而言，性能并不重要。（在这种情况下）
从维护的角度来看，2nd 选项更好。
在尽可能窄的范围内，在同一位置声明和初始化变量。
正如 Donald Ervin Knuth 所说：
“我们应该忘记小的效率，比如说大约 97% 的时间： 过早优化是万恶之源”
i.e) 程序员让性能考虑影响设计一段代码的情况。这可能会导致设计不像它可能的那样干净或不正确的代码，因为代码被复杂 优化，程序员被优化分心了。
【讨论】：
如果你也想在循环外使用str；在外面声明。否则，第二个版本就可以了。
【讨论】：
请跳到更新的答案...
对于那些关心性能的人，请取出 System.out 并将循环限制为 1 个字节。使用双精度（测试 1/2）和使用字符串（3/4）以毫秒为单位的经过时间在下面给出了 Windows 7 Professional 64 位和 JDK-1.7.0_21。字节码（下面也给出了 test1 和 test2）是不一样的。我懒得用可变和相对复杂的对象进行测试。
双倍
Test1 耗时：2710 毫秒
Test2 耗时：2790 毫秒
字符串（只是在测试中用字符串替换双精度）
Test3 耗时：1200 毫秒
Test4 耗时：3000 毫秒
编译和获取字节码
javac.exe LocalTest1.java
javap.exe -c LocalTest1 > LocalTest1.bc
public class LocalTest1 {
public static void main(String[] args) throws Exception {
long start = System.currentTimeMillis();
double test;
for (double i = 0; i < 1000000000; i++) {
test = i;
}
long finish = System.currentTimeMillis();
System.out.println("Test1 Took: " + (finish - start) + " msecs");
}
}
public class LocalTest2 {
public static void main(String[] args) throws Exception {
long start = System.currentTimeMillis();
for (double i = 0; i < 1000000000; i++) {
double test = i;
}
long finish = System.currentTimeMillis();
System.out.println("Test1 Took: " + (finish - start) + " msecs");
}
}
Compiled from "LocalTest1.java"
public class LocalTest1 {
public LocalTest1();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]) throws java.lang.Exception;
Code:
0: invokestatic #2 // Method java/lang/System.currentTimeMillis:()J
3: lstore_1
4: dconst_0
5: dstore 5
7: dload 5
9: ldc2_w #3 // double 1.0E9d
12: dcmpg
13: ifge 28
16: dload 5
18: dstore_3
19: dload 5
21: dconst_1
22: dadd
23: dstore 5
25: goto 7
28: invokestatic #2 // Method java/lang/System.currentTimeMillis:()J
31: lstore 5
33: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
36: new #6 // class java/lang/StringBuilder
39: dup
40: invokespecial #7 // Method java/lang/StringBuilder."<init>":()V
43: ldc #8 // String Test1 Took:
45: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
48: lload 5
50: lload_1
51: lsub
52: invokevirtual #10 // Method java/lang/StringBuilder.append:(J)Ljava/lang/StringBuilder;
55: ldc #11 // String msecs
57: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
60: invokevirtual #12 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
63: invokevirtual #13 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
66: return
}
Compiled from "LocalTest2.java"
public class LocalTest2 {
public LocalTest2();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]) throws java.lang.Exception;
Code:
0: invokestatic #2 // Method java/lang/System.currentTimeMillis:()J
3: lstore_1
4: dconst_0
5: dstore_3
6: dload_3
7: ldc2_w #3 // double 1.0E9d
10: dcmpg
11: ifge 24
14: dload_3
15: dstore 5
17: dload_3
18: dconst_1
19: dadd
20: dstore_3
21: goto 6
24: invokestatic #2 // Method java/lang/System.currentTimeMillis:()J
27: lstore_3
28: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
31: new #6 // class java/lang/StringBuilder
34: dup
35: invokespecial #7 // Method java/lang/StringBuilder."<init>":()V
38: ldc #8 // String Test1 Took:
40: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
43: lload_3
44: lload_1
45: lsub
46: invokevirtual #10 // Method java/lang/StringBuilder.append:(J)Ljava/lang/StringBuilder;
49: ldc #11 // String msecs
51: invokevirtual #9 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
54: invokevirtual #12 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
57: invokevirtual #13 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
60: return
}
将性能与所有 JVM 优化进行比较确实不容易。不过，这多少有些可能。 Google Caliper中更好的测试和详细结果
这与上面的代码不同。如果你只是编写一个虚拟循环，JVM 会跳过它，所以至少你需要分配和返回一些东西。 Caliper 文档中也建议这样做。
@Param int size; // Set automatically by framework, provided in the Main
/**
* Variable is declared inside the loop.
*
* @param reps
* @return
*/
public double timeDeclaredInside(int reps) {
/* Dummy variable needed to workaround smart JVM */
double dummy = 0;
/* Test loop */
for (double i = 0; i <= size; i++) {
/* Declaration and assignment */
double test = i;
/* Dummy assignment to fake JVM */
if(i == size) {
dummy = test;
}
}
return dummy;
}
/**
* Variable is declared before the loop.
*
* @param reps
* @return
*/
public double timeDeclaredBefore(int reps) {
/* Dummy variable needed to workaround smart JVM */
double dummy = 0;
/* Actual test variable */
double test = 0;
/* Test loop */
for (double i = 0; i <= size; i++) {
/* Assignment */
test = i;
/* Not actually needed here, but we need consistent performance results */
if(i == size) {
dummy = test;
}
}
return dummy;
}
总结：declaredBefore 表示更好的性能 - 非常小 - 并且它违反了最小范围原则。 JVM 实际上应该为您执行此操作
【讨论】：
在内部，变量可见的范围越小越好。
【讨论】：
解决这个问题的一个方法是提供一个封装 while 循环的变量范围：
{
// all tmp loop variables here ....
// ....
String str;
while(condition){
str = calculateStr();
.....
}
}
当外部作用域结束时，它们会自动取消引用。
【讨论】：
如果您不需要在 while 循环之后使用 str（范围相关），那么第二个条件即
while(condition){
String str = calculateStr();
.....
}
更好，因为如果您仅在 condition 为真时在堆栈上定义对象。 IE。 如果需要，请使用它
【讨论】：
我认为回答您问题的最佳资源是以下帖子：
Difference between declaring variables before or in loop?
据我了解，这将取决于语言。 IIRC Java 对此进行了优化，因此没有任何区别，但 JavaScript（例如）每次都会在循环中完成整个内存分配。特别是在 Java 中，我认为第二个在完成分析时会运行得更快。
【讨论】：
【讨论】：
根据 Google Android Development guide，变量范围应该是有限的。请检查此链接：
【讨论】：
在while 循环之外声明字符串str 允许在while 循环内部和外部引用它。在 while 循环内声明字符串 str 允许它仅在 while 循环内被引用。
【讨论】：
正如许多人指出的那样，
String str;
while(condition){
str = calculateStr();
.....
}
不比这更好：
while(condition){
String str = calculateStr();
.....
}
因此，如果您不重用变量，请不要在其范围之外声明变量...
【讨论】：
在循环内声明会限制相应变量的范围。这完全取决于项目对变量范围的要求。
【讨论】：
确实，上述问题是一个编程问题。您想如何编写代码？您需要在哪里访问“STR”？声明一个在本地用作全局变量的变量是没有用的。我相信的编程基础。
【讨论】：
str 变量将可用并在内存中保留一些空间，即使在下面的代码执行之后也是如此。
String str;
while(condition){
str = calculateStr();
.....
}
str 变量将不可用，并且在下面的代码中为str 变量分配的内存将被释放。
while(condition){
String str = calculateStr();
.....
}
如果我们确实遵循第二个，这将减少我们的系统内存并提高性能。
【讨论】：
这两个例子的结果是一样的。但是，第一个为您提供了在 while 循环之外使用 str 变量；第二个不是。
【讨论】：
我认为对象的大小也很重要。 在我的一个项目中，我们声明并初始化了一个大型二维数组，该数组使应用程序抛出内存不足异常。 我们将声明移出循环，并在每次迭代开始时清除数组。
【讨论】：
对这个问题中几乎每个人的警告：这是示例代码，在循环内部，使用Java 7 在我的计算机上它可以很容易地慢 200 倍（并且内存消耗也略有不同）。但它与分配有关，而不仅仅是范围。
public class Test
{
private final static int STUFF_SIZE = 512;
private final static long LOOP = 10000000l;
private static class Foo
{
private long[] bigStuff = new long[STUFF_SIZE];
public Foo(long value)
{
setValue(value);
}
public void setValue(long value)
{
// Putting value in a random place.
bigStuff[(int) (value % STUFF_SIZE)] = value;
}
public long getValue()
{
// Retrieving whatever value.
return bigStuff[STUFF_SIZE / 2];
}
}
public static long test1()
{
long total = 0;
for (long i = 0; i < LOOP; i++)
{
Foo foo = new Foo(i);
total += foo.getValue();
}
return total;
}
public static long test2()
{
long total = 0;
Foo foo = new Foo(0);
for (long i = 0; i < LOOP; i++)
{
foo.setValue(i);
total += foo.getValue();
}
return total;
}
public static void main(String[] args)
{
long start;
start = System.currentTimeMillis();
test1();
System.out.println(System.currentTimeMillis() - start);
start = System.currentTimeMillis();
test2();
System.out.println(System.currentTimeMillis() - start);
}
}
结论：根据局部变量的大小，差异可能很大，即使变量不是很大。
只是说有时候，循环外部或内部确实很重要。
【讨论】：
bigStuff[(int) (value % STUFF_SIZE)] = value;（试试2147483649L的值）
如果您的calculateStr() 方法返回null，然后您尝试调用str 上的方法，您就有NullPointerException 的风险。
更一般地，避免使用具有 null 值的变量。顺便说一句，它对类属性更强。
【讨论】：
NullPointerException. 的风险为零如果此代码尝试return str;，则会遇到编译错误。