内部/外部循环中的变量声明

Question

If for some reason I have to use as little memory space as possible, then is the second code bellow better that the first? (the code is just for illustration and doesn't have any meaning). (edit: imagine I want to make the assembly code of this before any optimization done by the JVM. Then do i use 99999998 extra memory locations in the first procedure compared to the second one? the focus is just one memory usage)

First:

for(int i=0; i<99999999; i++){
    int k=2*i
}

Second:

int k=0;
for(int i=0; i<99999999; i++){
    k=2*i
}

Answer 1

What I'm sure of :

In every case, The difference will not be visible. if you want to make such small optimization, Java is surely not the best technology. Which makes me recommend the first one cause it make the code more readable and logical. (Find it strange to declare a variable outside the for if you use it only inside it, it's confusing).

---

What I think :

In your small example and since your looking for a memory footprint. The first one is better because it follow the implicit rule mentioned in this comment : the smaller the scope is the better it is.

In the first case the variable k is used only in a really small loop. So the optimizer will easily understand it and use only a register, so no memory usage and less instructions.

In the second case, it will be harder for the optimizer to determine that k is not use elsewhere. So it could allow some memory instead of using a register. It will then use some memory and be less optimized since it will need instructions to load and store the memory.

As mentionned in this comment , it will mostly depend on how you use it. In your example the optimizer will detect it's the same usage in both case and will use no memory. But in harder code it will not always find it. So I recommend to have the smaller scope has possible.

Answer 2

@pranay-khandelwal 's response links to an excellent discussion of this question in a different language. The Java JVM, however, throws bytecode around at runtime to try to achieve better performance, which can complicate things.

There's actually another discussion here on a similar topic of in/out best practices in general for readability, which resulted in some benchmarks and discussion that one of the participants documented here

As a general rule of thumb the second option will be better for memory and performance under almost all circumstances - where the former may be more self-documenting and maintainable, and avoid accidental use elsewhere in the outer scope.

Since you mention that the code in your post is only a representative example and this could apply to more than just simple types:

Replacing the contents of an already registered memory area is less costly than registering a new one and deregistering the old one (or waiting for it to be garbage collected) . Even where a language's compiler or interpreter smartly uses recently unreferenced things to store new things, that work also takes work, and is overhead that can optimistically be avoided with outer declarations - though as others mention, this is usually an unnecessary and potentially bug-spawning micro-optimization.

Answer 3

As from these short examples you provided, the second option. However, it always depends on the logic of your code. Thinking about performance and minimising execution space and time, the second code scales better even though it looks countering some good coding practices. K in your code is used only inside the loop block. However, it is "reused" over multiple "block iterations". Take a look at the syntax of your for loop , it declares i ( int i ) in the beginning of the statement; this declaration will happen just once. Again, declaring the variable multiple times may lead to waste to time and memory. The JVM optimiser might do a good job in general, simple cases. However, it might fail in capturing the semantics of your code (Java).

for(int i=0,k=0; i<99999999; i++){
    k=2*i
}