性能优化

一、避免在循环条件中使用复杂表达式
在不做编译优化的情况下，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。 
例子： 

import java.util.vector;  
class cel {  
    void method (vector vector) {  
        for (int i = 0; i < vector.size (); i++)  // violation  
            ; // ...  
    }  
}  

更正： 
[java] view plain copy
class cel_fixed {  
    void method (vector vector) {  
        int size = vector.size ()  
        for (int i = 0; i < size; i++)  
            ; // ...  
    }  
}  

二、为'vectors' 和 'hashtables'定义初始大小 

jvm为vector扩充大小的时候需要重新创建一个更大的数组，将原原先数组中的内容复制过来，最后，原先的数组再被回收。可见vector容量的扩大是一个颇费时间的事。 
通常，默认的10个元素大小是不够的。你最好能准确的估计你所需要的最佳大小。 
例子： 

import java.util.vector;  
public class dic {  
    public void addobjects (object[] o) {  
        // if length > 10, vector needs to expand  
        for (int i = 0; i< o.length;i++) {      
            v.add(o);   // capacity before it can add more elements.  
        }  
    }  
    public vector v = new vector();  // no initialcapacity.  
}  

更正： 
自己设定初始大小。 
[java] view plain copy
public vector v = new vector(20);    
public hashtable hash = new hashtable(10);  

三、在finally块中关闭stream 
程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。       
例子： 

import java.io.*;  
public class cs {  
    public static void main (string args[]) {  
        cs cs = new cs ();  
        cs.method ();  
    }  
    public void method () {  
        try {  
            fileinputstream fis = new fileinputstream ("cs.java");  
            int count = 0;  
            while (fis.read () != -1)  
                count++;  
            system.out.println (count);  
            fis.close ();  
        } catch (filenotfoundexception e1) {  
        } catch (ioexception e2) {  
        }  
    }  
}         
更正： 
在最后一个catch后添加一个finally块 

四、使用'system.arraycopy ()'代替通过来循环复制数组 
'system.arraycopy ()' 要比通过循环来复制数组快的多。 
        
例子： 

public class irb  
{  
    void method () {  
        int[] array1 = new int [100];  
        for (int i = 0; i < array1.length; i++) {  
            array1 [i] = i;  
        }  
        int[] array2 = new int [100];  
        for (int i = 0; i < array2.length; i++) {  
            array2 [i] = array1 [i];                 // violation  
        }  
    }  
}        
更正： 
public class irb  
{  
    void method () {  
        int[] array1 = new int [100];  
        for (int i = 0; i < array1.length; i++) {  
            array1 [i] = i;  
        }  
        int[] array2 = new int [100];  
        system.arraycopy(array1, 0, array2, 0, 100);  
    }  
}  

五、让访问实例内变量的getter/setter方法变成”final” 
简单的getter/setter方法应该被置成final，这会告诉编译器，这个方法不会被重载，所以，可以变成”inlined” 
例子： 

class maf {  
    public void setsize (int size) {  
         _size = size;  
    }  
    private int _size;  
}  
更正： 
[java] view plain copy
class daf_fixed {  
    final public void setsize (int size) {  
         _size = size;  
    }  
    private int _size;  
}  

八、如果只是查找单个字符的话，用charat()代替startswith() 
用一个字符作为参数调用startswith()也会工作的很好，但从性能角度上来看，调用用string api无疑是错误的!      
例子： 

public class pcts {  
    private void method(string s) {  
        if (s.startswith("a")) { // violation  
            // ...  
        }  
    }  
}           
更正         
将'startswith()' 替换成'charat()'. 
[java] view plain copy
public class pcts {  
    private void method(string s) {  
        if ('a' == s.charat(0)) {  
            // ...  
        }  
    }  
}  

九、使用移位操作来代替'a / b'操作 
"/"是一个很“昂贵”的操作，使用移位操作将会更快更有效。 
例子： 

public class sdiv {  
    public static final int num = 16;  
    public void calculate(int a) {  
        int div = a / 4;            // should be replaced with "a >> 2".  
        int div2 = a / 8;         // should be replaced with "a >> 3".  
        int temp = a / 3;  
    }  
}  
更正： 
[java] view plain copy
public class sdiv {  
    public static final int num = 16;  
    public void calculate(int a) {  
        int div = a >> 2;    
        int div2 = a >> 3;  
        int temp = a / 3;       // 不能转换成位移操作  
    }  
}  

十、使用移位操作代替'a * b' 
同上。 
[i]但我个人认为，除非是在一个非常大的循环内，性能非常重要，而且你很清楚你自己在做什么，方可使用这种方法。否则提高性能所带来的程序晚读性的降低将是不合算的。 

例子： 

public class smul {  
    public void calculate(int a) {  
        int mul = a * 4;            // should be replaced with "a << 2".  
        int mul2 = 8 * a;         // should be replaced with "a << 3".  
        int temp = a * 3;  
    }  
}  
更正： 
[java] view plain copy
package opt;  
public class smul {  
    public void calculate(int a) {  
        int mul = a << 2;    
        int mul2 = a << 3;  
        int temp = a * 3;       // 不能转换  
    }  
}  

十一、在字符串相加的时候，使用 ' ' 代替 " "，如果该字符串只有一个字符的话 

例子： 

public class str {  
    public void method(string s) {  
        string string = s + "d"  // violation.  
        string = "abc" + "d"      // violation.  
    }  
}  
更正： 
将一个字符的字符串替换成' ' 
[java] view plain copy
public class str {  
    public void method(string s) {  
        string string = s + 'd'  
        string = "abc" + 'd'     
    }  
}

十二、不要在循环中调用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);  
}  
更正： 
不要在循环体中调用同步方法，如果必须同步的话，推荐以下方式： 
[java] view plain copy
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);  
}  

十三、将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) {}  
   }  

十六、用'stringtokenizer' 代替 'indexof()' 和'substring()' 
字符串的分析在很多应用中都是常见的。使用indexof()和substring()来分析字符串容易导致 stringindexoutofboundsexception。而使用stringtokenizer类来分析字符串则会容易一些，效率也会高一些。 
例子： 

public class ust {  
    void parsestring(string string) {  
        int index = 0;  
        while ((index = string.indexof(".", index)) != -1) {  
            system.out.println (string.substring(index, string.length()));  
        }  
    }  
}  

十七、使用条件操作符替代"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);  
    }  
}  

十八、使用条件操作符代替"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;  
}  

十九、不要在循环体中实例化变量 
在循环体中实例化临时变量将会增加内存消耗 
例子：         

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);  
        }  
    }  
}  

二十、确定 stringbuffer的容量 
stringbuffer的构造器会创建一个默认大小(通常是16)的字符数组。在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。在大多数情况下，你可以在创建stringbuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。 
例子：         

public class rsbc {  
    void method () {  
        stringbuffer buffer = new stringbuffer(); // violation  
        buffer.append ("hello");  
    }  
}          
更正：         
为stringbuffer提供寝大小。         
public class rsbc {  
    void method () {  
        stringbuffer buffer = new stringbuffer(max);  
        buffer.append ("hello");  
    }  
    private final int max = 100;  
}  

二十二、不要总是使用取反操作符(!) 
取反操作符(!)降低程序的可读性，所以不要总是使用。 
例子： 

public class dun {  
    boolean method (boolean a, boolean b) {  
        if (!a)  
            return !a;  
        else  
            return !b;  
    }  
}  

更正： 
如果可能不要使用取反操作符(!) 
10. 采用在需要的时候才开始创建的策略。 
例如： 

String str="abc";  
if(i==1){ list.add(str);}  
应修改为： 
if(i==1){String str="abc"; list.add(str);}  

17.不用new关键字创建对象的实例。 
用 new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用她的clone() 方法。clone()方法不会调用任何类构造函数。 
下面是Factory模式的一个典型实现。 

public static Credit getNewCredit()  
{  
    return new Credit();  
}  
改进后的代码使用clone() 方法， 
private static Credit BaseCredit = new Credit();  
public static Credit getNewCredit()  
{  
    return (Credit)BaseCredit.clone();  
}  

19.不要将数组声明为：public static final。 
20.HaspMap的遍历。 

Map<String, String[]> paraMap = new HashMap<String, String[]>();  
for( Entry<String, String[]> entry : paraMap.entrySet() )  
{  
    String appFieldDefId = entry.getKey();  
    String[] values = entry.getValue();  
}  

利用散列值取出相应的Entry做比较得到结果，取得entry的值之后直接取key和 value。 
27.考虑使用静态方法， 
如果你没有必要去访问对象的外部，那么就使你的方法成为静态方法。她会被更快地调用，因为她不需要一个虚拟函数导向表。这同事也是一个很好的实践，因为她告诉你如何区分方法的性质，调用这个方法不会改变对象的状态。 

数值表达式 
1. 奇偶判断 
不要使用 i % 2 == 1 来判断是否是奇数，因为i为负奇数时不成立，请使用 i % 2 != 0 来判断是否是奇数，或使用 高效式 (i & 1) != 0来判断。 
2. 小数精确计算 

System.out.println(2.00 -1.10);//0.8999999999999999  

上面的计算出的结果不是 0.9，而是一连串的小数。问题在于1.1这个数字不能被精确表示为一个double，因此它被表 示为最接近它的double值，该程序从2中减去的就是这个值，但这个计算的结果并不是最接近0.9的double值。 
一般地说，问题在于并不是所有的小数都可以用二进制浮点数精确表示。 
二进制浮点对于货币计算是非常不适合的，因为它不可能将1.0表示成10的其他任何负次幂。 
解决问题的第一种方式是使用货币的最小单位（分）来表示： 

System.out.println(200-110);//90  

第二种方式是使用BigDecimal，但一定要用BigDecimal(String)构造器，而千万不要用 BigDecimal(double)来构造（也不能将float或double型转换成String再来使用BigDecimal(String)来构造，
因为在将float或double转换成String时精度已丢失）。 
例如new BigDecimal(0.1)， 
它将返回一个BigDecimal， 
也即0.1000000000000000055511151231257827021181583404541015625， 
正确使用BigDecimal，程序就可以打印出我们所期 望的结果0.9： 

System.out.println(new BigDecimal("2.0").subtract(new BigDecimal("1.10")));// 0.9  

另外，如果要比较两个浮点数的大小，要使用BigDecimal的compareTo方法。 
3. int整数相乘溢出 
我们计算一天中的微秒数： 
long microsPerDay = 24 * 60 * 60 * 1000 * 1000;// 正确结果应为：86400000000  
System.out.println(microsPerDay);// 实际上为：500654080  
  问题在于计算过程中溢出了。这个计算式完全是以int运算来执行的，并且只有在运算完成之后，其结果才被提升为long，而此时已经太迟：计算已经溢出。 
  解决方法使计算表达式的第一个因子明确为long型，这样可以强制表达式中所有的后续计算都用long运算来完成，这样结果就不会溢出： 
long microsPerDay = 24L * 60 * 60 * 1000 * 1000;