التكرار على العناصر وfor المحسّنة

Written Explanation

The classic indexed loop

for (int i = 0; i < a.length; i++) {
    // a[i] is the current element
}

Read the three parts as a checklist for valid indices:

1. Start at 0, the first valid index.
2. Keep going while i < a.length. The last valid index is length - 1, so the loop must stop before length.
3. Step by i++ to move one locker at a time.

If you write i <= a.length, the body runs once more with i == a.length, and a[i] throws ArrayIndexOutOfBoundsException. This single character is the most common array bug there is.

You can also count down, or visit only part of an array:

for (int i = a.length - 1; i >= 0; i--) { ... }   // backwards: last index down to 0
for (int i = 1; i < a.length; i++) { ... }        // skip the first element

The enhanced for loop

When you want each value and do not care about its position, Java has a shorter form (the language specification calls it the enhanced for statement):

for (int s : scores) {
    // s is the current element
}

Read the colon as "in": "for each int s in scores". The loop visits every element from the first to the last, in order. There is no index to get wrong, so no off-by-one is possible. It works the same way for String[], double[], and every other array type.

Which loop should I use?

The enhanced loop is the right default for reading. Reach for the indexed loop when the table says so.

A trap: the loop variable is a copy

In for (int s : scores), the variable s is a copy of the current element. Assigning to s changes the copy and leaves the array alone:

for (int p : prices) {
    p = p * 2;     // changes only p; prices is unchanged
}

To modify an array, use the indexed loop and write prices[i] = .... The same holds for String[]: n = n.toUpperCase() reassigns the local variable only. (Strings cannot be modified at all, as BEG-009 explained.)

Staying inside the bounds

Before you run a loop, ask one question about every array access: is the index at least 0 and at most length - 1? Check the first and the last iteration by hand. When the body reads a neighbour, the range must shrink:

for (int i = 0; i < a.length - 1; i++) {
    // a[i] and a[i + 1] are both valid here
}

The loop stops at length - 2, so i + 1 is at most length - 1.

The empty array

new int[0] or {} is a legal array of length 0. A loop over it runs zero times, with no error, because 0 < 0 is false from the start. Code that uses a[0] directly (such as starting a "maximum" at a[0]) does crash on an empty array, so test a.length == 0 first when empty input is possible.