J2ME循环与String优化设计

 通常我们撰写循环时，习惯让计数变量从0 开始，然后累加。但是，只要做一点小小的更改，就可以让程序跑的更快，范例程序如下:　　//PerfTest.java
　　import javax.microedition.midlet.*;
　　import javax.microedition.lcdui.*;
　　public class PerfTest extends MIDlet
　　{
　　public PerfTest()
　　{
　　}
　　public void startApp()
　　{
　　long start,end ;
　　start = System.currentTimeMillis() ;
　　for(int i=0 ; i < 9000000 ; i++) ;
　　end = System.currentTimeMillis() ;
　　System.out.println("Normal loop : "+ (end-start) + " milliseconds") ;
　　start = System.currentTimeMillis() ;
　　for(int i=8999999 ; i >= 0 ; i--) ;
　　end = System.currentTimeMillis() ;
　　System.out.println("Optimized loop : "+ (end-start) + " milliseconds") ;
　　}
　　public void pauseApp()
　　{
　　}
　　public void destroyApp(boolean unconditional)
　　{
　　}
　　}

 

　　执行结果:

　　Normal loop : 2046 milliseconds
　　Optimized loop : 1563 milliseconds

 

　　从上述范例我们可以发现，跑900 万次，单单跑循环而以就相差约500 毫秒，将进1/4 的效能提升。

　　这个范例可以扩大到任何使用到比较运算符(>、>=、<、<=、!=)。之所以会有效能的提升，是因为如果任何数值要与0 比较，在底层都有对应较简单的指令可以对应，也因此加速了程序的执行。范例的第一段程序代码被编译成:

　　0 invokestatic #2 <Method long currentTimeMillis()>
　　3 lstore_1
　　4 iconst_0
　　5 istore 5
　　7 goto 13
　　10 iinc 5 1
　　13 iload 5
　　15 ldc #3 <Integer 9000000>
　　17 if_icmplt 10
　　20 invokestatic #2 <Method long currentTimeMillis()>
　　23 lstore_3
　　24 getstatic #4 <Field java.io.PrintStream out>
　　27 new #5 <Class java.lang.StringBuffer>
　　30 dup
　　31 invokespecial #6 <Method java.lang.StringBuffer()>
　　34 ldc #7 <String "Normal loop : ">
　　36 invokevirtual #8 <Method java.lang.StringBuffer append(java.lang.String)>
　　39 lload_3
　　40 lload_1
　　41 lsub
　　42 invokevirtual #9 <Method java.lang.StringBuffer append(long)>
　　45 ldc #10 <String " milliseconds">
　　47 invokevirtual #8 <Method java.lang.StringBuffer append(java.lang.String)>
　　50 invokevirtual #11 <Method java.lang.String toString()>
　　53 invokevirtual #12 <Method void println(java.lang.String)>

 

　　而第二段程序代码被编译成

　　56 invokestatic #2 <Method long currentTimeMillis()>
　　59 lstore_1
　　60 ldc #13 <Integer 8999999>
　　62 istore 6
　　64 goto 70
　　67 iinc 6 -1
　　70 iload 6
　　72 ifgt 67
　　75 invokestatic #2 <Method long currentTimeMillis()>
　　78 lstore_3
　　79 getstatic #4 <Field java.io.PrintStream out>
　　82 new #5 <Class java.lang.StringBuffer>
　　85 dup
　　86 invokespecial #6 <Method java.lang.StringBuffer()>
　　89 ldc #14 <String "Optimized loop : ">
　　91 invokevirtual #8 <Method java.lang.StringBuffer append(java.lang.String)>
　　94 lload_3
　　95 lload_1
　　96 lsub
　　97 invokevirtual #9 <Method java.lang.StringBuffer append(long)>
　　100 ldc #10 <String " milliseconds">
　　102 invokevirtual #8 <Method java.lang.StringBuffer append(java.lang.String)>
　　105 invokevirtual #11 <Method java.lang.String toString()>
　　108 invokevirtual #12 <Method void println(java.lang.String)>

 

　　所以速度加快了。

　　String 的最佳化

　　通常我们要处理字符串时，第一个想到的就是String 类别，范例如下:

　　//StringBufferTest.java
　　import javax.microedition.midlet.*;
　　import javax.microedition.lcdui.*;
　　public class StringBufferTest extends MIDlet
　　{
　　public StringBufferTest()
　　{
　　}
　　public void startApp()
　　{
　　Runtime rt = Runtime.getRuntime() ;
　　long diffstart = rt.totalMemory()-rt.freeMemory();
　　System.out.println("Memory used Start:" + diffstart) ;
　　//注意，底下的程序代码没有任何意义，纯粹要展示String 有多耗内存
　　String sum = "" ;
　　for(int i=0 ; i< 5000 ; i++)
　　{
　　sum = sum + "+" + i ;
　　}
　　long diffend = rt.totalMemory()-rt.freeMemory();
　　System.out.println("Memory used End:" + diffend) ;
　　System.out.println("Memory used after operation:" + (diffend-diffstart)) ;
　　}
　　public void pauseApp()
　　{
　　}
　　public void destroyApp(boolean unconditional)
　　{
　　}
　　}

 

　　执行结果:

　　Memory used Start:28564
　　Memory used End:259864
　　Memory used after operation:231300

 

　　在此范例程序中，我们使用Runtime 类别的totoalMemory()来取得系统所有的内存大小，使用freeMemory()来取得可用内存的大小，两者相减之后约略是中间程序代码执行时所占用的内存大小。我们可以发现，循环执行500 次，耗掉了约231300 byte 的内存。如果我们把String 用StringBuffer 来替代:

　　//StringBufferTest.java
　　import javax.microedition.midlet.*;
　　import javax.microedition.lcdui.*;
　　public class StringBufferTest extends MIDlet
　　{
　　public StringBufferTest()
　　{
　　}
　　public void startApp()
　　{
　　Runtime rt = Runtime.getRuntime() ;
　　long diffstart = rt.totalMemory()-rt.freeMemory();
　　System.out.println("Memory used Start:" + diffstart) ;
　　//注意，底下的程序代码没有任何意义，纯粹要展示StringBuffer
　　StringBuffer sum = new StringBuffer("");
　　for(int i=0 ; i< 5000 ; i++)
　　{
　　sum = sum.append("+").append(i) ;
　　}
　　long diffend = rt.totalMemory()-rt.freeMemory();
　　System.out.println("Memory used End:" + diffend) ;
　　System.out.println("Memory used after operation:" + (diffend-diffstart)) ;
　　}
　　public void pauseApp()
　　{
　　}
　　public void destroyApp(boolean unconditional)
　　{
　　}
　　}

 

　　执行结果:

　　Memory used Start:28548
　　Memory used End:160848
　　Memory used after operation:132300

 

　　我们发现，改用StringBuffer 之后，循环同样执行500 次，，一样效果的程序代码，但内存只耗掉了132300 byte 的内存。少了将近一倍，这告诉我们，虽然StringBuffer 无法完全取代，但是如果可以的话，尽量使用StringBuffer。

 

　　之所以有节省内存的效果，是因为String 对象的设计采用了immutable 这种设计模式(Design Pattern)，这是为了安全性的考量。