Question

String s = ''; for(i=0;i<....){     s = some Assignment; } 

or

for(i=0;i<..){     String s = some Assignment; } 

I don’t need to use ‘s’ outside the loop ever again. The first option is perhaps better since a new String is not initialized each time. The second however would result in the scope of the variable being limited to the loop itself.

EDIT: In response to Milhous’s answer. It’d be pointless to assign the String to a constant within a loop wouldn’t it? No, here ‘some Assignment’ means a changing value got from the list being iterated through.

Also, the question isn’t because I’m worried about memory management. Just want to know which is better.

Answer 1

Limited Scope is Best

Use your second option:

for ( ... ) {   String s = ...; } 

Scope Doesn’t Affect Performance

If you disassemble code the compiled from each (with the JDK’s javap tool), you will see that the loop compiles to the exact same JVM instructions in both cases. Note also that Brian R. Bondy’s ‘Option #3’ is identical to Option #1. Nothing extra is added or removed from the stack when using the tighter scope, and same data are used on the stack in both cases.

Avoid Premature Initialization

The only difference between the two cases is that, in the first example, the variable s is unnecessarily initialized. This is a separate issue from the location of the variable declaration. This adds two wasted instructions (to load a string constant and store it in a stack frame slot). A good static analysis tool will warn you that you are never reading the value you assign to s, and a good JIT compiler will probably elide it at runtime.

You could fix this simply by using an empty declaration (i.e., String s;), but this is considered bad practice and has another side-effect discussed below.

Often a bogus value like null is assigned to a variable simply to hush a compiler error that a variable is read without being initialized. This error can be taken as a hint that the variable scope is too large, and that it is being declared before it is needed to receive a valid value. Empty declarations force you to consider every code path; don’t ignore this valuable warning by assigning a bogus value.

Conserve Stack Slots

As mentioned, while the JVM instructions are the same in both cases, there is a subtle side-effect that makes it best, at a JVM level, to use the most limited scope possible. This is visible in the ‘local variable table’ for the method. Consider what happens if you have multiple loops, with the variables declared in unnecessarily large scope:

void x(String[] strings, Integer[] integers) {   String s;   for (int i = 0; i < strings.length; ++i) {     s = strings[0];     ...   }   Integer n;   for (int i = 0; i < integers.length; ++i) {     n = integers[i];     ...   } } 

The variables s and n could be declared inside their respective loops, but since they are not, the compiler uses two ‘slots’ in the stack frame. If they were declared inside the loop, the compiler can reuse the same slot, making the stack frame smaller.

What Really Matters

However, most of these issues are immaterial. A good JIT compiler will see that it is not possible to read the initial value you are wastefully assigning, and optimize the assignment away. Saving a slot here or there isn’t going to make or break your application.

The important thing is to make your code readable and easy to maintain, and in that respect, using a limited scope is clearly better. The smaller scope a variable has, the easier it is to comprehend how it is used and what impact any changes to the code will have.