Re: Which scope for variables being used in a loop?
bugnthecode wrote:
Now my original thinking was that I would declare the strings outside
of the loop so that I'm not re-creating a reference each time through
the loop; I would just keep re-assigning it. Then I started to think
that maybe this wasn't doing as I expected, and the realized that
those 3 strings stay in scope until the end of the method meaning the
locations would be unavailable to the gc until the method was finished
processing. In the above snippet that really doesn't matter, but what
if I had much more code below the loop.
So my question is which way would be better on memory or performance.
Which is better coding style if performance and memory usage are
negligible either way?
I don't think that there's any doubt that the best coding style is to declare
variables in the most restricted scope possible. Not only does it make the
code more readable, but it reduces the chances of errors by mistakenly re-using
a value which had been set in an earlier passage of code where it was used for
something else. A counter-point to that view is that if your methods are so
long that it makes any difference where you declare variables, then your
methods are too long anyway. There's some truth in that, but it is difficult
to write sensible Java code where methods /are/ properly short (say 2 or 3
lines, not counting the brackets).
From an efficiency POV, it makes no difference at all. None. Zero. Java
bytecode has no concept of a local variable (or stack slot, actually) at a
narrower scope than a method. So the bytecode generated for:
public void printCustomers(List<Customer> customers)
{
String customerName;
String customerPhone;
String customerLocation;
for(Customer customer : customers)
{
customerName = customer.getName();
customerPhone = customer.getPhone();
customerLocation = customer.getLocation();
System.out.println(customerName+customerPhone+customerLocation);
}
and:
public void printCustomers2(List<Customer> customers)
{
for(Customer customer : customers)
{
String customerName = customer.getName();
String customerPhone = customer.getPhone();
String customerLocation = customer.getLocation();
System.out.println(customerName+customerPhone+customerLocation);
}
are essentially identical (as you can verify with javap, if you feel so
inclined). I tried that with the javac from jdk 1.6.0, and the only difference
(for some reason) was that it assigned the variables to stack slots in a
different order.
Note that javac and/or the JIT is at liberty to generate code to null-out stack
slots once they are no longer live, but in fact (as far as I can tell) the
current implementations do not do so (there's to be some #ifdef-ed-out code in
the 1.6 JVM source, which /seems/ as if it might be an experimental
implementation of that idea, but...). However, since there's no difference in
the bytecode, the JIT will, or won't, do that no matter which way you phrase
your code.
-- chris