CODEWITHSUNDEEP
javaarrayscoding-stylefor-loop
Marshall Farrier
Marshall Farrier

Reputation: 967

Java for-loop best practice

What is the best way to loop through an array when you need the index?

Option 1:

int len = array.length;
for (int i = 0; i < len; ++i) {
    array[i] = foo(i);
}

Option 2:

for (int i = 0; i < array.length; i++) {
    array[i] = foo(i);
}

Or, does it not matter? Or is there a better way to do it? Just to point out the differences: In one case, the length of the array is evaluated as part of the test in the loop, although the compiler should normally optimize that.

Secondly, is ++i any different here from i++? I definitely prefer ++i if it is C++ but am not sure for Java.

Upvotes: 8

Views: 2675

Answers (4)

Ced
Ced

Reputation: 17367

In addition to arshaji response I wanted to know if there was a performance benefit of using size() in a loop vs storing it in advance. I believe the result show that the compiler does optimize things and accessing the length of a list is the same as accessing a variable ( I was worried that the fact it had to go through a function would slow down things).

Here is the time it takes for those two for different method of loop:

for(long i = 0 ; i < mylist.size(); i++){}
VS
for(long i = 0 ; i < 10_000_000; i++){}

Here is the result for a list of ten million elems:

fixed length:
,162,157,151,157,156,159,157,149,150,170,158,153,152,158,151,151,156,156,151,153
getSize:
,164,156,159,154,151,160,162,152,154,152,151,149,168,156,152,150,157,150,156,157



import java.util.ArrayList;
import java.util.List;

public class Main {

    final static int LENGTH_SAMPLE = 20;
    final static long LENGTH = 10_000_000;

    public static void main(String[] args) {

        List<Long> mylist = new ArrayList<>();
        for(long i = 0 ; i < LENGTH; i++){
            mylist.add(i);
        }
        System.out.println("fixed length:");
        for(int i = 0 ; i < LENGTH_SAMPLE; i++){
            System.out.printf("," + fixedSize(mylist));
        }
        System.out.println("");
        System.out.println("getSize:");
        for(int i = 0 ; i < LENGTH_SAMPLE; i++){
            System.out.printf("," + fctSize(mylist));
        }
    }

    private static long fixedSize(List list){
        long start = System.currentTimeMillis();

        for(long i = 0 ; i < LENGTH; i++){
            System.currentTimeMillis();
        }
        return System.currentTimeMillis() - start;
    }

    private static long fctSize(List list){
        long start = System.currentTimeMillis();

        for(long i = 0 ; i < list.size(); i++){
            System.currentTimeMillis();
        }
        return System.currentTimeMillis() - start;
    }
}

Upvotes: 0

arshajii
arshajii

Reputation: 129537

Generally those two methods are equivalent. You should note that in 

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

the foo() is called once before each iteration (as opposed to only once before the first iteration), so you might want to take this into account for more complicated situations by perhaps doing something like

int n = foo();
for (int i = 0 ; i < n ; i++) {
    ...
}

which is analogous to your Option 1. So I would say Option 1 is certainly the safer of the two, but most of the time it should not make a significant difference which you use.

As for your second question: ++i first increments your variable and then retrieves it's value, i++ first retrieves the value and then increments. Just try these two pieces of code:

int i = 0;
System.out.println(++i);
------------------------
int i = 0;
System.out.println(i++);

The first prints 1 but the second prints 0. Of course when ++i and i++ are alone it makes no difference.

Upvotes: 6

user1107832
user1107832

Reputation: 1

for whether to use "array.length" in for loop: Generally the compiler will do some optimization, as a result it is equivalent to using a variable in the for loop

for "i++" and "++i" In C++, ++i is preferred and more efficient, but in Java, they are equivalent in this case.

Upvotes: 0

Dan
Dan

Reputation: 10786

i++ vs ++i does not matter in this particular case. While C masters will tell you to store array.length in a variable, modern optimizing compilers make that unnecessary in this case as long as the length does not change in the loop. If you're really concerned you can benchmark both, but since .length doesn't actually need to traverse the entire array each time you'll be OK.

Upvotes: 6

Related Questions