Java优化

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 (Vector vector) {

        int size = vector.size ()

        for (int i = 0; i < size; i++)

            ; // ...

    }

}

 

二、为'Vectors' 和 'Hashtables' StringBuffer定义初始大小

 

JVMVector扩充大小的时候需要重新创建一个更大的数组,将原原先数组中的内容复制过来,最后,原先的数组再被回收。可见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块中关闭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;

}

 

更正:

class DAF_fixed {

    final public void setSize (int size) {

         _size = size;

    }

    private int _size;

}

 

 

六、避免不需要的instanceof操作

 

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

         

      

更正:         

删掉不需要的instanceof操作。

         

class Dog extends UISO {

    void method () {

        Dog d;

        System.out.println ("Dog is an UISO");

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

    }

}

 

 

七、避免不需要的强制转换类型操作

 

所有的类都是直接或者间接继承自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' 

 

同上。

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

    }

}

 

更正:

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被关闭或者你所使用的是一个不带JITJVM,性能会将下降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

{

    boolean method (String string) {

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

    }

}

 

更正:

class UEQ_fixed

{

    boolean method (String string) {

        return string.endsWith ("a");

    }

}

 

 

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

 

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

例子:

public class USC {

    String method () {

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

        }

    }

}

 

 

 

十七、使用条件操作符(三目运算)替代"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;

}

         

 

二十一、尽可能的使用栈变量(局部变量)

 

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

         

例子:

public class USV {

    void getSum (int[] values) {

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

            _sum += value[i];           // violation.

        }

    }

    void getSum2 (int[] values) {

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

            _staticSum += value[i];

        }

    }

    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[i];

    }

    _sum = sum;

}

         

 

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

 

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

 

例子:

public class DUN {

    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 {}

 

 

少用new初始化一个实例:

尽量少用new来初始化一个类的实例,当一个对象是用new进行初始化时,其构造函数链的所有构造函数都被调用到,所以new操作符是很消耗系统资源的,new一个对象耗时往往是局部变量赋值耗时的上千倍。同时,当生成对象后,系统还要花时间进行垃圾回收和处理。

  当new创建对象不可避免时,注意避免多次的使用new初始化一个对象。

  尽量在使用时再创建该对象。如:

NewObject object = new NewObject();
int value;
if(i0 )
{
 value =object.getValue();
}
上面一段代码可以修改为:

int value;
if(i0 )
{
 NewObject object = new NewObject();
 Value =object.getValue();
}

异常应该用在错误处理的情况,不应该用来控制程序流程,流程尽量用whileif等处理。

异常是Java的一种错误处理机制,对程序来说是非常有用的,但是异常对性能不利。抛出异常首先要创建一个新的对象,并进行相关的处理,造成系统的开销,所以

在不是很影响代码健壮性的前提下,可以把几个try/catch块合成一个。

尽量使用局部变量和静态变量:

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

  尽量使用静态变量,即加修饰符static,如果类中的变量不会随他的实例而变化,就可以定义为静态变量,从而使他所有的实例都共享这个变量。 

   

同步处理技巧:应该尽可能减少同步

同步主要出现在多线程的情况,为多线程同时运行时提供对象数据安全的机制,多线程是比较复杂话题,应用多线程也是为了获得性能的提升,应该尽可能减少同步。

  另外,如果需要同步的地方,可以减少同步的代码段,如只同步某个方法或函数,而不是整个代码。
尽量减少I/O操作:(不必要的日志输出)

                      输入/输出(I/O)包括很多方面,我们知道,进行I/O操作是很消耗系统资源的。程序中应该尽量少用I/O操作。使用时可以注意: 合理控制输出函数System.out.println()对于大多时候是有用的,特别是系统调试的时候,但也会产生大量的信息出现在控制台和日志上,同时输出时,有序列化和同步的过程,造成了开销。

  特别是在发行版中,要合理的控制输出,可以在项目开发时,设计好一个Debug的工具类,在该类中可以实现输出开关,输出的级别,根据不同的情况进行不同的输出的控制。

尽量使用缓存对象如BufferedReader BufferedWriter BufferedInputStream等:

读写内存要比读写硬盘上的文件要快很多,应尽可能使用缓冲,以便直接从内存中读取数据。

  尽可能使用带有Buffer的类代替没有Buffer的类,如可以用BufferedReader 代替Reader,用BufferedWriter代替Writer来进行处理I/O操作。

  同样可以用BufferedInputStream代替InputStream都可以获得性能的提高 

尽量不使用同步:

Servlet是多线程的,以处理不同的请求,基于前面同步的分析,如果有太多的同步就失去了多线程的优势了。

不用保存太多的信息在HttpSession

  很多时候,存储一些对象在HttpSession中是有必要的,可以加快系统的开发,如网上商店系统会把购物车信息保存在该用户的Session中,但当存储大量的信息或是大的对象在会话中时,是有害的,特别是当系统中用户的访问量很大,对内存的需求就会很高。
  具体开发时,在这两者之间应作好权衡。
清除SESSION

通常情况,当达到设定的超时时间时,同时有些Session没有了活动,服务器会释放这些没有活动的Session.. 不过这种情况下,特别是多用户并访时,系统内存要维护多个的无效Session

  当用户退出时,应该手动释放,回收资源,实现如下:..

HttpSession theSession = request.getSession();
// 获取当前Session
if(theSession != null){
 theSession.invalidate(); // 使该Session失效
}

 

 

分级存储


1)数据库数据分级存储:

  将经常访问的数据和访问频度低的数据,分别存放到不同的分区,甚至存放到不同的数据库服务器,以便合进分配硬盘I/O及系统I/O

 

2)网站内容发布之后,分级存储:

  任何一个大型的网站,一般都有海量的内容,为了提高访问效率,应搭建分级存储体系,根据应用的重要性和访问并发要求,将这些内容分级存储,同时将静态内容中的静态页面文件、图片文件、下载文件分不同的Web服务器访问,降低I/O争用,提高访问效率,同时让数据存储、管理、备份更加清晰。

3)
页面静态化



  一个大型网站,既有静态内容,也有动态内容。静态内容,直接通过Apache或者Squid访问,效率高,稳定可靠,更多的是受服务器等硬件设备的I/O吞吐量、网络环境及页面代码本身质量限制,不受应用系统及数据库性能限制,这些内容往往访问速度和效率不会有较大的问题。

  而动态内容,除了受硬件设备I/O、操作系统I/O及内容、网络环境及页面代码的影响,还要受应用服务器和数据库性能影响,因此,这部份内容,要尽可能作静态化或者伪静态,并采用缓存技术,将其缓存,以减少对应用服务器和数据库服务器的操作次数,提高用户访问效率和稳定性。

缓存策略


对于构建的业务系统,如果有些数据要经常要从数据库中读取,同时,这些数据又不经常变化,这些数据就可以在系统中缓存起来,使用时直接读取缓存,而不用频繁的访问数据库读取数据。

  缓存工作可以在系统初始化时一次性读取数据,特别是一些只读的数据,当数据更新时更新数据库内容,同时更新缓存的数据值。

  例如:在天极CMS2005系统中,我们将很少发生变化的网站节点树数据,缓存在客户端,当用户登录时,一次性读入到客户端缓存起来,以后编辑在使用时,不用再从数据库中读取,大大提高了应用系统的访问速度。

  当然,也可以将数据库中重复访问的数据缓存在应用服务器内存中,减少对数据库的访问次数,Java常用的缓存技术产品有:MemoryCache、OSCache等。

通常把大循环放在里面,把小循环放在外面

    例如:将

    for(int i=0; i<10;i++)

    {

for(int j=0; j<1000000;j++)

  

}

    }

 

 

  3。基本数据类型

  ■ 在重要的循环里使用基本数据类型(int型数据通常比long/double型数据更快)

  ■ 基本数据类型(Boolean,Integer,etc)的包装类主要用在当传递的方法参数必须是一个对象的引用时(而不是一个基本数据类型)

  ■ 对所有的常量代数表达式使用static final修饰符

  ■ 使常量更容易引用(编译器预先计算常量表达式)

  

   

  8。不要重复初始化变量

  ■默认情况下,调用类的构造函数时, Java会把变量初始化成确定的值:所有的对象被设置成null,整数变量(byte、short、int、long)设置成0,float和 double变量设置成0.0,逻辑值设置成false。

  当一个类从另一个类派生时,这一点尤其应该注意,因为用new关键词创建一个对象时,构造函数链中的所有构造函数都会被自动调用。

  9。尽量指定类的final修饰符

  ■带有final修饰符的类是不可派生的。在Java核心API中,有许多应用final的例子,例如java.lang.String。为String类指定final防止了人们覆盖length()方法。

  另外,如果指定一个类为final,则该类所有的方法都是final。Java编译器会寻找机会内联(inline)所有的final方法(这和具体的编译器实现有关)。此举能够使性能平均提高50%。

  10。尽量使用局部变量

  ■调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack)中,速度较快。其他变量,如静态变量、实例变量等,都在堆(Heap)中创建,速度较慢。另外,依赖于具体的编译器/JVM,局部变量还可能得到进一步优化。请参见《尽可能使用堆栈变量》。

   

    12 在JSP页面中关闭无用的会话。

    一个常见的误解是以为session在有客户端访问时就被创建,然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建,注意如果JSP没有显示的使用 <[email=%@page]%@page[/email] session="false"%> 关闭session,则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。由于session会消耗内存资源,因此,如果不打算使用session,应该在所有的JSP中关闭它。对于那些无需跟踪会话状态的页面,关闭自动创建的会话可以节省一些资源。使用如下page指令:<%@ page session="false"%>

     

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

    17 由于JVM的有其自身的GC机制,不需要程序开发者的过多考虑,从一定程度上减轻了开发者负担,但同时也遗漏了隐患,过分的创建对象会消耗系统的大量内存,严重时会导致内存泄露,因此,保证过期对象的及时回收具有重要意义。JVM回收垃圾的条件是:对象不在被引用;然而,JVM的GC并非十分的机智,即使对象满足了垃圾回收的条件也不一定会被立即回收。所以,建议我们在对象使用完毕,应手动置成null。

    18 在使用同步机制时,应尽量使用方法同步代替代码块同步。

    19 尽量采用懒加载的策略,即在需要的时候才开始创建。

例如:    String str = “aaa”;                                  

应替换为:

if(i == 1) 

{

        if(i==1) {                                                                                     String str = “aaa”;

                list.add(str);  

                                                                          list.add(str);

}                  

    

选择合适的引用机制

在典型的 JSP 应用系统中 , 页头 、 页脚部分往往被抽取出来 , 然后根据需要引入页头 、 页脚 。

当前,在 JSP 页面中引入外部资源的方法主要有两种: include 指令,以及 include 动作。

include 指令 : 例如 <%@ include file="copyright.html" %> 。 该指令在编译时引入指定的资源 。

在编译之前,带有 include 指令的页面和指定的资源被合并成一个文件。被引用的外部资源

在编译时就确定,比运行时才确定资源更高效。

include 动作 : 例如 <jsp:include page="copyright.jsp" /> 。 该动作引入指定页面执行后生成的结

果 。 由于它在运行时完成 , 因此对输出结果的控制更加灵活 。 但时 , 只有当被引用的内容频

繁地改变时 , 或者在对主页面的请求没有出现之前 , 被引用的页面无法确定时 , 使用 includ e

动作才合算。

 

HashMap 的遍历效率讨论

Iterator iter = map.entrySet().iterator();  高于

terator iter = map.keySet().iterator();  

 

 array( 数组 和 ArryList 的使用

array ( [] ) :最高效;但是其容量固定且无法动态改变;

ArrayList :容量可动态增长;但牺牲效率;

基于效率和类型检验,应尽可能使用 array ,无法确定数组大小时才使用 ArrayList 

 

 

 内存数据库

许多应用需要以用户为单位在会话对象中保存相当数量的数据,典型的应用如购物篮和目录等。由于这类数据可以按照行/列的形式组织,因此,许多应用创建了庞大的VectorHashMap。在会话中保存这类数据极大地限制了应用的可伸缩性,因为服务器拥有的内存至少必须达到每个会话占用的内存数量乘以并发用户最大数量,它不仅使服务器价格昂贵,而且垃圾收集的时间间隔也可能延长到难以忍受的程度。

 

一些人把购物篮/目录功能转移到数据库层,在一定程度上提高了可伸缩性。然而,把这部分功能放到数据库层也存在问题,且问题的根源与大多数关系数据库系统的体系结构有关。对于关系数据库来说,运行时的重要原则之一是确保所有的写入操作稳定、可靠,因而,所有的性能问题都与物理上把数据写入磁盘的能力有关。关系数据库力图减少I/O操作,特别是对于读操作,但实现该目标的主要途径只是执行一套实现缓冲机制的复杂算法,而这正是数据库层第一号性能瓶颈通常总是CPU的主要原因。

 

一种替代传统关系数据库的方案是,使用在内存中运行的数据库(In-memory Database),例如TimesTen。内存数据库的出发点是允许数据临时地写入,但这些数据不必永久地保存到磁盘上,所有的操作都在内存中进行。这样,内存数据库不需要复杂的算法来减少I/O操作,而且可以采用比较简单的加锁机制,因而速度很快。

 

对小数据intInteger封装,尽量的使用Integer.valueOf()创建,而不要使用new来创建。因为Integer类缓存了从-128256个 状态的Integer

 

如果字符串特别长,不要釆用charAt()一一的获取特定位置的字符,而应该调用toCharArray()方法转化为字符数组,然后通过数组 索引值获取指定位置的字符。

 

posted @ 2013-07-30 11:11  嗨,你的益达~~~  阅读(433)  评论(0编辑  收藏  举报