浅谈Java程序优化

颜色说明

颜色	说明
*****橙色*****	重点优化对象，必须遵守。
*****黑色*****	能够提高性能，建议使用，但是不强制要求。

一、      避免在循环条件中使用复杂表达式

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

例子：

import java.util.Vector;

 

class CEL

{

    void method(Vector vector)

    {

        for (int i = 0; i < vector.size(); i++) // Violation

        ; // ...

    }

}

 

更正：

class CEL_fixed

{

void method (Vectorvector)

{

        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.

}

更正：

自己设定初始大小。

    public Vector v = new Vector(20);

public Hashtable hash = new Hashtable(10);

三、     在finally块中关闭数据库连接、I/O流操作，以释放资源

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

例子：

import java.io.*;

public class CS

{

    public static void main(String args[])

    {

        CS cs = new CS();

        cs.method();

    }

   

    public void method()

{

        FileInputStream fis = null;

        try

        {

            fis = new FileInputStream("CS.java");

            int count = 0;

            while (fis.read() != -1)

            {

                count++;

            }

            System.out.println(count);

        }

        catch (FileNotFoundException e1)

        {

        }

        catch (IOException e2)

        {

        }

        finally

       {

           fis.close();

       }

    }

}

四、     使用'System.arraycopy ()'代替通过来循环复制数组

'System.arraycopy ()' 要比通过循环来复制数组快的多。

例子：

public class IRB

{

    void method()

    {

        int[] array1 = new int[100];

        for (int i = 0; i < array1.length; i++)

        {

            array1 = i;

        }

        int[] array2 = new int[100];

        for (int i = 0; i < array2.length; i++)

        {

            array2 = array1; // Violation

        }

    }

}

更正：

public class IRB

{

    void method()

    {

        int[] array1 = new int[100];

        for (int i = 0; i < array1.length; i++)

        {

            array1 = 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;

}

 

更正：

class DAF_fixed {

    final public void setSize (int size) {

         _size = size;

    }

    private int _size;

}

六、     避免不需要的instanceof操作

如果左边的对象的静态类型等于右边的，instanceof表达式返回永远为true。

例子：

public class UISO {

    public UISO () {}

}

class Dog extends UISO {

    void method (Dog dog, UISO u) {

        Dog d = dog;

        if (d instanceof UISO) // always true.

            System.out.println("Dog is aUISO");

        UISO uiso = u;

        if (uiso instanceof Object) // alwaystrue.

            System.out.println("uiso is anObject");

    }

}

更正：

删掉不需要的instanceof操作。

class Dog extends UISO {

    void method () {

        Dog d;

        System.out.println ("Dog is anUISO");

        System.out.println ("UISO is anUISO");

    }

}

七、     避免不需要的造型操作

所有的类都是直接或者间接继承自Object。同样，所有的子类也都隐含的"等于"其父类。那么，由子类造型至父类的操作就是不必要的了。

例子：

class UNC

{

    String _id = "UNC";

}

 

class Dog extends UNC

{

    void method()

    {

        Dog dog = new Dog();

        UNC animal = (UNC)dog; // not necessary.

        Object o = (Object)dog; // not necessary.

    }

}

更正：

class Dog extends UNC

{

    void method()

    {

        Dog dog = new Dog();

        UNC animal = dog;

        Object o = dog;

    }

}

八、     如果只是查找单个字符的话，用charAt()代替startsWith()

用一个字符作为参数调用startsWith()也会工作的很好，但从性能角度上来看，调用用String API无疑是错误的!

例子：

public class PCTS

{

    private void method(String s)

    {

        if (s.startsWith("a"))

        { // violation

            // ...

        }

    }

}

更正

将'startsWith()' 替换成'charAt()'.

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;

   }

}

更正：

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'

同上。

但我个人认为，除非是在一个非常大的循环内，性能非常重要，而且你很清楚你自己在做什么，方可使用这种方法。否则提高性能所带来的程序晚读性的降低将是不合算的。

例子：

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;

    }

}

更正：

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.

    }

}

更正：

将一个字符的字符串替换成' '

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

}

 

更正：

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

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)

        {

           

        }

    }

十四、        对于boolean值，避免不必要的等式判断

将一个boolean值与一个true比较是一个恒等操作(直接返回该boolean变量的值).移走对于boolean的不必要操作至少会带来2个好处：

1)代码执行的更快 (生成的字节码少了5个字节)；

2)代码也会更加干净 。

例子：

public class UEQ

{

booleanmethod (String string)

{

        return string.endsWith ("a")== true;   // Violation

    }

}

 

更正：

class UEQ_fixed

{

booleanmethod (String string)

{

        return string.endsWith("a");

    }

}

十五、        对于常量字符串，用'String' 代替 'StringBuffer'

常量字符串并不需要动态改变长度。

例子：

public class USC

{

Stringmethod ()

{

        StringBuffer s = new StringBuffer("Hello");

        String t = s + "World!";

        return t;

    }

}

更正：

把StringBuffer换成String，如果确定这个String不会再变的话，这将会减少运行开销提高性能。

 

十六、        用'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()));

        }

    }

}

十七、        不要在循环体中实例化变量

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

 

例子：        

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;

}

十九、        尽可能的使用栈变量

如果一个变量需要经常访问，那么你就需要考虑这个变量的作用域了。static? local?还是实例变量？访问静态变量和实例变量将会比访问局部变量多耗费2-3个时钟周期。

例子：

public class USV

{

    void getSum(int[] values)

    {

        for (int i = 0; i < value.length; i++)

        {

            _sum += value; // violation.

        }

    }

 

    void getSum2(int[] values)

    {

        for (int i = 0; i < value.length; i++)

        {

            _staticSum += value;

        }

    }

 

    private int _sum;

    private static int _staticSum;

}

更正：

如果可能，请使用局部变量作为你经常访问的变量。

你可以按下面的方法来修改getSum()方法：

void getSum (int[] values)

{

    int sum = _sum; // temporary local variable.

    for (int i=0; i < value.length; i++)

    {

        sum += value;

    }

    _sum = sum;

}

二十、        不要总是使用取反操作符(!)

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

例子：

public class test

{

    boolean method(boolean a, boolean b)

    {

        if (!a)

        {

            return !a;

        }

        else

        {

            return !b;

        }

    }

}

更正：

如果可能不要使用取反操作符(!)

二十一、           与一个接口进行instanceof操作

基于接口的设计通常是件好事，因为它允许有不同的实现，而又保持灵活。只要可能，对一个对象进行instanceof操作，以判断它是否某一接口要比是否某一个类要快。

例子：

public class INSOF {

    private void method (Object o) {

        if (o instanceof InterfaceBase) {}  // better

        if (o instanceof ClassBase) { }   // worse.

    }

}

 

class ClassBase {}

interface InterfaceBase {}

二十二、           异常对性能不利

抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地（Native）方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。

异常只能用于错误处理，不应该用来控制程序流程。

 

二十三、           不用new关键词创建类的实例

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

在使用设计模式（Design Pattern）的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。例如，下面是Factory模式的一个典型实现：

public static Credit getNewCredit()

{

    return new Credit();

}

改进后的代码使用clone()方法，如下所示：

private static Credit BaseCredit =new Credit();

public static Credit getNewCredit() {

return (Credit) BaseCredit.clone();

}

二十四、           尽量使用局部变量

调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。

二十五、           避免对象创建和GC

只要有可能，应该避免创建对象，防止调用构造函数带来的相关性能成本，以及在对象结束其生命周期时进行垃圾收集所带来的成本。考虑以下这些准则：

·    只要有可能，就使用基本变量类型，而不使用对象类型。例如，使用 int，而不使用 Integer；

·    缓存那些频繁使用的寿命短的对象，避免一遍又一遍地重复创建相同的对象，并因此加重垃圾收集的负担；

·    在处理字符串时，使用 StringBuffer 而不使用字符串String进行连接操作，因为字符串对象具有不可变的特性，并且需要创建额外的字符串对象以完成相应的操作，而这些对象最终必须经历 GC；

·    避免过度地进行 Java 控制台的写操作，降低字符串对象处理、文本格式化和输出带来的成本；

·    实现数据库连接池，重用连接对象，而不是重复地打开和关闭连接；

·    使用线程池（thread pooling），避免不停地创建和删除线程对象，特别是在大量使用线程的时候；

·    避免在代码中调用GC。GC是一个“停止所有处理（stop the world）”的事件，它意味着除了 GC 线程自身外，其他所有执行线程都将处于挂起状态。如果必须调用 GC，那么可以在非紧急阶段或空闲阶段实现它；

·    避免在循环内分配对象。

·    尽早释放无用对象的引用。大多数程序员在使用临时变量的时候，都是让引用变量在退出活动域（scope）后，自动设置为null。我们在使用这种方式时候，必须特别注意一些复杂的对象，例如数组，队列，树，图等，这些对象之间的相互引用关系较为复杂。对于这类对象，GC回收它们一般效率较低。如果程序允许，尽早将不再使用的引用对象赋为null。这样可以加速GC的工作。

·    如果有经常使用的图片，可以使用soft引用类型。它可以尽可能将图片保存在内存中，供程序调用，而不引起Out Of Memory。

·    注意一些全局的变量，以及一些静态变量。这些变量往往容易引起悬挂对象（dangling reference），造成内存浪费。

·    使用String a ="a";定义字符串，而不是使用Stringa = new String("a");

二十六、           避免非常大的分配

有时候问题不是由当时的堆状态造成的，而是因为分配失败造成的。分配的内存块都必须是连续的，而随着堆越来越满，找到较大的连续块越来越困难。这不仅仅是 Java 的问题，使用 C 中的 malloc 也会遇到这个问题。JVM 在压缩阶段通过重新分配引用来减少碎片，但其代价是要冻结应用程序较长的时间。

 

二十七、           SQL语句大写

在JAVA + ORACLE 的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担。

 

二十八、           尽量重用对象，特别是String 对象的使用中，出现字符串连接情况时应用StringBuffer代替

由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响；

例子：

StringBuffer sqlbuff = newStringBuffer();

 

sqlbuff.append("select to_char(decode(parent_item_id ,(select parent_item_id froms_finance_item_2009 where item_id=10),null,parent_item_id)) up_id, "

+

" to_char(item_id)id,item_name name ");

 

sqlbuff.append(" froms_finance_item_2009 start with item_id=10 connect by parent_item_id= prioritem_id ");

 

二十九、           由于JVM的有其自身的GC机制，不需要程序开发者的过多考虑，从一定程度上减轻了开发者负担，但同时也遗漏了隐患，过分的创建对象会消耗系统的大量内存，严重时会导致内存泄露；

JVM回收垃圾的条件是：对象不在被引用；然而，JVM的GC并非十分的机智，即使对象满足了垃圾回收的条件也不一定会被立即回收。所以，建议我们在对象使用完毕，应手动置成null；

 

示例代码：

Object[] rvo = new Object[2];

ArrayList tlist = new ArrayList();

tlist = BOQueryResult.getInstence().getQueryResult(sql,BOQueryResult.integrateSqlAgent);

if (tlist.size() == 1)

{

    rvo = (Object[]) tlist.get(0);

    //对象使用完毕，手工释放对象

    tlist = null;

}

return rvo;

 

三十、        尽量使用HashMap 和ArrayList ,除非必要，否则不推荐使用HashTable和Vector ，后者由于使用同步机制，而导致了性能的开销；

 

三十一、           array(数组)和 ArryList的使用

array（[]）：最高效；但是其容量固定且无法动态改变；
ArrayList：容量可动态增长；但牺牲效率；
基于效率和类型检验，应尽可能使用array，无法确定数组大小时才使用ArrayList！
ArrayList是Array的复杂版本
ArrayList内部封装了一个Object类型的数组，从一般的意义来说，它和数组没有本质的差别，甚至于ArrayList的许多方法，如Index、IndexOf、Contains、Sort等都是在内部数组的基础上直接调用Array的对应方法。
ArrayList存入对象时，抛弃类型信息，所有对象屏蔽为Object，编译时不检查类型，但是运行时会报错。
注：jdk5中加入了对泛型的支持，已经可以在使用ArrayList时进行类型检查。
从这一点上看来，ArrayList与数组的区别主要就是由于动态增容的效率问题了；

 

三十二、           在进行金额计算时使用BigDecimal

对于帐务系统中金额处理的运行，一律采用BigDecimal。

 

转换元为分

        BigDecimal money = new BigDecimal(100);

       money = money.movePointLeft(2);

处理结果为：1.00

转换分为元

        BigDecimal money = new BigDecimal(100);

       money = money.movePointRight(2);

处理结果为：10000