How bad is declaring arrays inside a for loop in Java?

Question

I come from a C background, so I admit that I'm still struggling with letting go of memory management when writing in Java. Here's one issue that's come up a few times that I would love to get some elaboration on. Here are two ways to write the same routine, the only difference being when double[] array is declared:

Code Sample 1:

double[] array;
for (int i=0; i<n; ++i) {
    array = calculateSomethingAndReturnAnArray(i);
    if (someFunctionOnArrays(array)) {
        // DO ONE THING
    } else {
        // DO SOME OTHER THING
    }
}

Code Sample 2:

for (int i=0; i<n; ++i) {
    double[] array = calculateSomethingAndReturnAnArray(i);
    if (someFunctionOnArrays(array)) {
        // DO ONE THING
    } else {
        // DO SOME OTHER THING
    }
}

Here, private double[] calculateSomethingAndReturnAnArray(int i) always returns an array of the same length. I have a strong aversion to Code Sample 2 because it creates a new array for each iteration when it could just overwrite the existing array. However, I think this might be one of those times when I should just sit back and let Java handle the situation for me.

What are the reasons to prefer one of the ways over the other or are they truly identical in Java?

You're creating a new array in both scenarios. You're merely *declaring* the array only once in the first sample (the storage for which is 32 bits since it's just a reference). But presumably `calculateSomethingAndReturnAnArray` is always instantiating a new array, which is where the real cost lies. — Kirk Woll, Sep 01 '11 at 22:55

score 8 · Accepted Answer · edited May 23 '17 at 11:55

There's nothing special about arrays here because you're not allocating for the array, you're just creating a new variable, it's equivalent to:

Object foo;
for(...){
    foo = func(...);
}

In the case where you create the variable outside the loop it, the variable (which will hold the location of the thing it refers to) will only ever be allocated once, in the case where you create the variable inside the loop, the variable may be reallocated for in each iteration, but my guess is the compiler or the JIT will fix that in an optimization step.

I'd consider this a micro-optimization, if you're running into problems with this segment of your code, you should be making decisions based on measurements rather than on the specs alone, if you're not running into issues with this segment of code, you should do the semantically correct thing and declare the variable in the scope that makes sense.

See also this similar question about best practices.

Stephen C · Answer 2 · 2011-09-01T23:30:29.227

A declaration of a local variable without an initializing expression will do NO work whatsoever. The work happens when the variable is initialized.

Thus, the following are identical with respects to semantics and performance:

double[] array;
for (int i=0; i<n; ++i) {
    array = calculateSomethingAndReturnAnArray(i);
    // ...
}

and

for (int i=0; i<n; ++i) {
    double[] array = calculateSomethingAndReturnAnArray(i);
    // ...
}

(You can't even quibble that the first case allows the array to be used after the loop ends. For that to be legal, array has to have a definite value after the loop, and it doesn't unless you add an initializer to the declaration; e.g. double[] array = null;)

To elaborate on @Mark Elliot 's point about micro-optimization:

This is really an attempt to optimize rather than a real optimization, because (as I noted) it should have no effect.
Even if the Java compiler actually emitted some non-trivial executable code for double[] array;, the chances are that the time to execute would be insignificant compared with the total execution time of the loop body, and of the application as a whole. Hence, this is most likely to be a pointless optimization.
Even if this is a worthwhile optimization, you have to consider that you have optimized for a specific target platform; i.e. a particular combination of hardware and JVM version. Micro-optimizations like this may not be optimal on other platforms, and could in theory be anti-optimizations.

In summary, you are most likely wasting your time if you focus on things like this when writing Java code. If performance is a concern for your application, focus on the MACRO level performance; e.g. things like algorithmic complexity, good database / query design, patterns of network interactions, and so on.

score 0 · Answer 3 · answered Sep 01 '11 at 22:56

0

Both create a new array for each iteration. They have the same semantics.

answered Sep 01 '11 at 22:56

Thomas Eding

35,312
13
75
106

How bad is declaring arrays inside a for loop in Java?

3 Answers3

Linked