Java：在for循环中调用arr.length的次数是多少？

Question

If arr is an array of size 10, in the following code block, how many times is arr.length accessed?

for (int i = 0; i < arr.length; ++i);

Once? Or every time it loops?

Thanks everyone! Here's what I ended up doing:

final int len = arr.length;
for (int i = 0; i < len; ++i);

Answer 1

Eleven times....

10 times, the statement i < arr.length evaluates to true .
1 time it evalutes to false and the loop ends.

Answer 2

Since you are permitted to change arr within the loop, it's usually evaluated every time the loop termination condition is evaluated.

An optimising compiler (or JIT) may recognise that you don't change arr within the loop, and then only evaluate arr.length once.

Answer 3

Without compiler optimizations, 11 times (one per iteration + one after the last iteration). But the compiler will optimize the thing so there's going to be only one access. But what I said assumes your for loop has a body:

for (int i = 0; i < arr.length; ++i) {
   ...
}

In your case the loop has no body:

for (int i = 0; i < arr.length; ++i);

so it's a no-op and the compiler is going to remove it. So in that specific case you'll access the field zero times.

But don't rely on compiler optimizations because you don't really know what it does.

Answer 4

zero is a possible answer in a decent modern vm.

in your specific loop, since it doesn't do anything, most likely vm will completely bypass it.

in the following example

size = ...
arr = new byte[size];
for (int i = 0; i < arr.length; ++i)
    non-trivial-statements;

vm could deduce that arr.length==size, which is already in a register, therefore size is used directly.

more interestingly, it knows that i<arr.length already , therefore arr[i] doesn't need runtime bound check, making array access as cheap as C array.

However, Java the language doesn't dictate these things. a vm can access it zero times, or a million times, it's all correct as long as the observable effects are the same.

the point is, you shouldn't worry about it. programs written in the common fashion are most likely subject to heavy optimization. following the crowd pays off in this case.

Answer 5

Every time it loops by definition. It might be optimized to 1 if you are lucky.

Answer 6

for (int i=0, n=arr.length; i<n; i++); is a simple idiom that neither

• a) relies on the compiler nor
• b) requires a non-loop scoped variable to hold the length, and
• c) evaluates arr.length just once

Answer 7

You could also do some experiments like

public class Count{

    private static int count; 

    private static int getLength(Object[] arr) {
        count += 1;
        return arr.length;
    }

    public static void main(String[] args){
        count = 0;
        Object[] arr = new Object[10];
        for (int i = 0; i < getLength(arr); ++i) {
            // do something
        }
        System.out.printf("called %d times%n", count);
    }
}    

for more details also print the value of i and the returned value of getLength (or use a debugger).

For fast online testing have a look at Youjavait or ideone .