In this case, the variables are allocated on the stack, as they are
"local". I do not think this could lead to out of memory (unless the
collection is gigantic). Personally I never like the idea of declaring
variables within a loop, and have not seen a lot of instances where it
is done.

-cheers,
Manish

Did you know under what circumstances ,are u sure the List-typed
customer will big enough to run out of your memory ,if so how about
the place which create this customer list.Maybe somewhere else.

By the way ,if the you can add/override toString() method to class
Customer ,that can avoid re-creation and assign value to local string
object.

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