I for one am tired of hearing the StringBuffer String story. Now I see programmers use stringbuffer making ugly code on a single call that will use 10 minutes of processor time. You only need to optimize where its mecessary. Most of you code will not be performance critical. Make it simple make it readable and optimize it after performance test or never if its good enough. Guessing what is performance critical is not worth while and often impossible.At least Pramati was real not opinion on what costscheers Rob
This is code "crappy" vs "clever" string concatination :
public class TestStringConcat {
public String concatinateCrappy( String strings[] ){
String str = "";
for( int i = 0; i < strings.length; i++ ){
str += strings[i];
}
return str;
}
public String concatinateClever( String strings[] ){
StringBuffer buff = new StringBuffer();
for( int i = 0; i < strings.length; i++ ){
buff.append(strings[i]);
}
return buff.toString();
}
}
This is compiled code :
Compiled from "TestStringConcat.java"
public class TestStringConcat extends java.lang.Object{
public TestStringConcat();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
public java.lang.String concatinateCrappy(java.lang.String[]);
Code:
0: ldc #2; //String
2: astore_2
3: iconst_0
4: istore_3
5: iload_3
6: aload_1
7: arraylength
8: if_icmpge 38
11: new #3; //class StringBuffer
14: dup
15: invokespecial #4; //Method java/lang/StringBuffer."<init>":()V
18: aload_2
19: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
22: aload_1
23: iload_3
24: aaload
25: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
28: invokevirtual #6; //Method java/lang/StringBuffer.toString:()Ljava/lang/String;
31: astore_2
32: iinc 3, 1
35: goto 5
38: aload_2
39: areturn
public java.lang.String concatinateClever(java.lang.String[]);
Code:
0: new #3; //class StringBuffer
3: dup
4: invokespecial #4; //Method java/lang/StringBuffer."<init>":()V
7: astore_2
8: iconst_0
9: istore_3
10: iload_3
11: aload_1
12: arraylength
13: if_icmpge 30
16: aload_2
17: aload_1
18: iload_3
19: aaload
20: invokevirtual #5; //Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
23: pop
24: iinc 3, 1
27: goto 10
30: aload_2
31: invokevirtual #6; //Method java/lang/StringBuffer.toString:()Ljava/lang/String;
34: areturn
}
"concatinateCrappy" creates object instance per iteration, but as I understand there is no mojor difference for java application performance. Most of this kind optimizations are useless and it is better to optimize "architecture"
( drop some useless code, layers and contracts )
BTW "concatinateCrappy" is faster then strings.length == 0 :)