Common For‑Loop Optimizations in Java

In everyday Java development, poorly written loops can become hidden performance killers; this article summarizes over ten common optimization patterns that make for‑loops more efficient and maintainable.

Method 1: Straightforward Loop

List<String> list = new ArrayList<String>();
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

Advantage: simple and easy to understand.

Disadvantage: list.size() is evaluated on every iteration.

Method 2: Cache Size in a Variable

int m = list.size();
for (int i = 0; i < m; i++) {
    System.out.println(list.get(i));
}

Advantage: size is computed only once.

Disadvantage: the variable’s scope is larger than necessary and the loop cannot handle size changes during iteration.

Method 3: Cache Size in the Loop Header

for (int i = 0, n = list.size(); i < n; i++) {
    System.out.println(list.get(i));
}

Advantage: size is computed once and the variable scope follows the minimal‑scope principle.

Disadvantage: same scope limitation as Method 2.

Method 4: Reverse Iteration

for (int i = list.size() - 1; i >= 0; i--) {
    System.out.println(list.get(i));
}

Advantage: no repeated size calculation and minimal scope.

Disadvantage: order of results is reversed and the code may be less readable; best used when order does not matter (e.g., validation before saving).

Method 5: Iterator Traversal

for (Iterator<String> it = list.iterator(); it.hasNext();) {
    System.out.println(it.next());
}

Advantage: concise and avoids index handling.

Method 6: Enhanced For‑Loop (Java 5+)

for (Object o : list) {
    System.out.println(o);
}

Advantage: very concise when used with generics.

Disadvantage: not compatible with Java 1.4 and earlier, and the index is unavailable.

Method 7: Outer‑Small‑Inner‑Large Loop Principle

for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10000; j++) {
        // inner work
    }
}

Placing the loop with fewer iterations on the outside reduces total loop overhead.

Method 8: Extract Invariant Computation

// Before
int a = 10, b = 11;
for (int i = 0; i < 10; i++) {
    i = i * a * b;
}
// After
int c = a * b;
for (int i = 0; i < 10; i++) {
    i = i * c;
}

Moving calculations that do not depend on the loop variable outside the loop saves repeated work.

Method 9: Move Exception Handling Outside the Loop

Bad example (exception inside the loop):

for (int i = 0; i < 10; i++) {
    try {
        // risky code
    } catch (Exception e) {
        // handle
    }
}

Good example (exception outside the loop):

try {
    for (int i = 0; i < 10; i++) {
        // risky code
    }
} catch (Exception e) {
    // handle
}

If the loop should continue after an exception, keep the try‑catch inside the loop; otherwise, place it outside to avoid repeated handling overhead.

Method 10: Reverse Deletion

When removing elements without an iterator, iterate backwards to avoid index shift problems.

for (int i = list.size() - 1; i >= 0; i--) {
    // loop body
    list.remove(i);
}

Method 11: Reduce Method Calls Inside the Loop

Cache results of frequently called methods before the loop.

int size = list.size();
int result = calculateResult();
for (int i = 0; i < size; i++) {
    // use cached result
}

These small details, when accumulated across many codebases, can significantly affect overall system performance, so developers should pay attention to them during daily coding.

Source: blog.csdn.net