Optimization of for loop

Operations that often use cyclic time-consuming calculations , In especial for loop , If not handled well , It takes quite a long time , If handled and written properly, it will greatly improve efficiency , Here's a summary for Common optimization methods of loops .

One 、 Eliminate the method call when the loop terminates the judgment

Before optimization ：

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

** advantage ：** More common , Easy to understand
** shortcoming ：** Count every time list.size()

1️⃣ Optimize one ： Will calculate list Length of the code extracted

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

** advantage ：** You don't have to calculate every time list The length of
shortcoming ：

1. m The scope of is not small enough , Violation of the minimum scope principle .
2. Can't be in for Operation in cycle list Size , Such as removing or adding a new element

explain ：
list.size() Each cycle is executed , This will undoubtedly affect the performance of the program , So it should be put out of the loop , Replace with a variable , The comparison before and after optimization is also obvious .

2️⃣ Optimization II ： Will calculate list Length of the code extracted

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

** advantage ：** You don't have to calculate every time , The scope of variables follows the principle of minimum scope .

3️⃣ Optimize three ： In reverse order

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

** advantage ：** You don't have to calculate every time , The scope of variables follows the principle of minimum scope .
shortcoming ：

1. The order of results will be reversed .
2. I don't seem used to , Not easy to read .

** Applicable occasions ：** Independent of the order in which the results are displayed , For example, check the data before saving .

Two 、 A nested loop Outside small inside big principle ( From the outside to the inside , Loop objects size From small to large )

Before optimization ：

for (int i = 0; i < 100000; i++) {
    
    for (int j = 0; j < 10; j++) {
    
    }
}

After optimization ：

for (int i = 0; i < 10; i++) {
    
    for (int j = 0; j < 100000; j++) {
    
    }
}

** understand ：** This is like the difference between copying many small files and copying several large files .

3、 ... and 、 Loop nesting extracts logic that does not need a loop

Before optimization ：

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

After optimization ：

int c = a * b;
for (int i = 0; i < 10; i++) {
    
    i = i * c;
}

** explain ：** In the code a*b Not related to circulation , To avoid double counting , It should be put outside . After optimization, the performance will be improved by several orders of magnitude , These cannot be ignored .

Four 、 Exception handling is written outside the loop

Before optimization ：

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

After optimization ：

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

** explain ：** Catching exceptions is resource intensive , So we can't try catch Put it inside the loop , After optimization, there are also several orders of magnitude improvements .

5、 ... and 、Iterator Traverse

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

** advantage ：** concise

6、 ... and 、jdk1.5 neographism

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

advantage ： Concise combination Generic Use more succinctly .
shortcoming ：jdk1.4 Down incompatibility .