Best idiom for a decrementing loop

Question

What's the best/preferred idiom for a decrementing for loop, and why?

for(int idx=(len-1); idx>=0; idx--) {...}

or

for(int idx=(len-1); idx>-1; idx--) {...}

or (based on sylvarking's answer, but using for to constrain the index scope)

for(int idx=len; idx-->0; ) {...}

Is one or the other more likely to trip up another developer?

Answer 1

First one; it's the standard way.

Answer 2

I can't say I've ever seen the latter, so here's one vote for the first one.

There should be no performance difference.

Note your loops iterate over max+1 elements. Normally I suppose I'd expect iteration from max-1 down to 0.

Answer 3

Interesting question! Personally, I use the first and it is the one I see used most by other programmers. I think the reason is that people are used to testing for zero and the -1 might throw them a bit.

Answer 4

Another array-oriented variant you might see is this:

int n = foo.length;
while (n-- > 0) {
  /* Do something with foo[n] */
}

Of the options you show, I prefer the first.

• 0 is (arguably) more readable than -1.
• Comparison to zero is usually faster than comparison to other constants. It is a single instruction that examines a single value on the stack. Other comparisons use one instruction to push a constant onto the stack and another instruction to compare the top two values.

Answer 5

The second is still confusing me.
The first is (more or less) what one is expecting, in a decrementing for loop, one does not have to check for >-1 just not to have the equals.

Personally I would've done as Mark Byers wrote.

Answer 6

I recommend the following because comparison against zero is optimized at the byte code level.

for(int idx=(len-1); idx>=0; idx--) {...}

This is a suggestion from Java Performance Tuning by Jack Shirazi

Answer 7

i have found that for-loops with a counter should only go from zero and up to some limit.

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

This is so well established that you can expect that anybody who sees this immediately understand what is going on. This also means that any DEVIATION from that form, by counting backwards or starting at one or stepping by three, makes it hard to understand because you need to recognize it is dfifferent, parse it and understand it. This includes all your examples.

I would suggest writing it clearly:

for(int i = 0; i < MAX; i++) {
  indexFromEnd = (MAX - 1) - i;
....
 }

Answer 8

If you have a list use a ListIterator:

Following example based on http://www.java-samples.com/showtutorial.php?tutorialid=235

class ListIter {
    public static void main(String args[]) {
     // create an array list
     ArrayList al = new ArrayList();
     // add elements to the array list
     al.add("A");
     al.add("B");
     al.add("C");
     al.add("D");
     al.add("E");
     al.add("F");
     // use ListIterator to display contents of al backwards
     ListIterator litr = al.listIterator(al.size());
     while (litr.hasPrevious()) {

      Object element = litr.previous();
      System.out.print(element + " ");

     }
     System.out.println();
    }
}

Answer 9

My vote is for:

for(int idx=(len-1); idx>=0; idx--)

And as an aside, I favor the prefix increment/decrement operator (--idx) in for for-loops, since it will avoid taking an unnecessary copy of idx (though many compilers will probably recognize this and fix it for you).