Java程序性能优化总结--------流程控制篇

　优化判断语句

1.使用条件操作符替代"if (cond) return; else return;" 结构

条件操作符更加的简捷
例子：
public class IF {

   public int method(boolean isDone) {
       if (isDone) {
         return 0;
       } else {
           return 10;
       }
   }
}

更正：
public class IF {
   public int method(boolean isDone) {
       return (isDone ? 0 : 10);
   }
}

2.使用条件操作符代替"if (cond) a = b; else a = c;" 结构

例子：
public class IFAS {
   void method(boolean isTrue) {
       if (isTrue) {
           _value = 0;
       } else {
           _value = 1;
       }
   }
   private int _value = 0;
}

更正：

public class IFAS {
   void method(boolean isTrue) {
       _value = (isTrue ? 0 : 1);       // compact expression.
   }
   private int _value = 0;

}

 

　优化循环体

　　循环是比较重复运行的地方，如果循环次数很大，循环体内不好的代码对效率的影响就会被放大而变的突出。考虑下面的代码片：..

Vector vect = new Vector(1000);
...
for( inti=0; i＜vect.size(); i++){
　...
}

　　for循环部分改写成：

int size = vect.size();
for( int i=0; i＞size; i++){
　...
}

　　如果size=1000，就可以减少1000次size()的系统调用开销，避免了循环体重复调用。

　　再看如下的代码片：..

for (int i = 0;i ＜100000;i++)
if (i%10 == 9) {
　... // 每十次执行一次
}

　　改写成也可以提高效率：..

for(inti =0,j =10; i＜100000; i++,j--){
　if(j == 0){
　　... // 每十次执行一次
　　j = 10;
　}
}

　　所以，当有较大的循环时，应该检查循环内是否有效率不高的地方，寻找更优的方案加以改进。

　1.不要在循环中调用synchronized(同步)方法

方法的同步需要消耗相当大的资料，在一个循环中调用它绝对不是一个好主意。

例子：
import java.util.Vector;
public class SYN {
   public synchronized void method (Object o) {
   }
   private void test () {

       for (int i = 0; i < vector.size(); i++) {
           method (vector.elementAt(i));    // violation
       }
   }
   private Vector vector = new Vector (5, 5);
}

更正：
不要在循环体中调用同步方法，如果必须同步的话，推荐以下方式：

import java.util.Vector;
public class SYN {

   public void method (Object o) {
   }
private void test () {
   synchronized{//在一个同步块中执行非同步方法
           for (int i = 0; i < vector.size(); i++) {
               method (vector.elementAt(i));  
           }
       }
   }
   private Vector vector = new Vector (5, 5);
}

　2.　将try/catch块移出循环

把try/catch块放入循环体内，会极大的影响性能，如果编译JIT被关闭或者你所使用的是一个不带JIT的JVM，性能会将下降21%之多!
       
例子：        
import java.io.FileInputStream;
public class TRY {
   void method (FileInputStream fis) {
       for (int i = 0; i < size; i++) {
           try {                                      // violation
               _sum += fis.read();
           } catch (Exception e) {}
       }

   }
   private int _sum;
}
       
更正：        
将try/catch块移出循环        
   void method (FileInputStream fis) {
       try {
           for (int i = 0; i < size; i++) {
               _sum += fis.read();

       }
       } catch (Exception e) {}
   }

　3.　不要在循环体中实例化变量

在循环体中实例化临时变量将会增加内存消耗

例子：        
import java.util.Vector;
public class LOOP {
   void method (Vector v) {
       for (int i=0;i < v.size();i++) {
           Object o = new Object();
           o = v.elementAt(i);

 }
   }
}
       
更正：        
在循环体外定义变量，并反复使用        
import java.util.Vector;
public class LOOP {
   void method (Vector v) {

       Object o;

 for (int i=0;i<v.size();i++) {
           o = v.elementAt(i);
       }
   }
}