使用String還是StringBuffer

 出於方便的考慮，我們在進行字符串的內容處理的時候往往會出現以下的代碼：
        String result="";
        result+="ok";

這段代碼看上去好像沒有什麼問題，但是需要指出的是其性能很低，原因是java中的String類不可變的（immutable），這段代碼實際的工作過程會是如何的呢？通過使用javap工具我們可以知道其實上面的代碼在編譯成字節碼的時候等同的源代碼是：
        String result="";
        StringBuffer temp=new StringBuffer();
        temp.append(result);
        temp.append("ok");
        result=temp.toString();

短短的兩個語句怎麼呢變成這麼多呢？問題的原因就在String類的不可變性上，而java程序爲了方便簡單的字符串使用方式對+操作符進行了重載，而這個重載的處理可能因此誤導很多對java中String的使用。
下面給出一個完整的代碼：

2. public class Perf {
3.   public static String detab1(String s)
4.   {
5.     if (s.indexOf('/t') == -1)
6.       return s;
7.     String res = "";
8.     int len = s.length();
9.     int pos = 0;
10.     int i = 0;
11.     for (; i < len && s.charAt(i) == '/t'; i++) 
12.     {
13.       res += "        ";
14.       pos += 8;
15.     }
16.     for (; i < len; i++) 
17.     {
18.       char c = s.charAt(i);
19.       if (c == '/t') {
20.         do {
21.           res += " ";
22.           pos++;
23.         } while (pos % 8 != 0);
24.       }
25.       else {
26.         res += c;
27.         pos++;
28.       }
29.     }
30.     return res;
31.   }
32.       
33.   public static String detab2(String s)
34.   {
35.     if (s.indexOf('/t') == -1)
36.       return s;
37.     StringBuffer sb = new StringBuffer();
38.     int len = s.length();
39.     int pos = 0;
40.     int i = 0;
41.     for (; i < len && s.charAt(i) == '/t'; i++) 
42.     {
43.       sb.append("        ");
44.       pos += 8;
45.     }
46.     for (; i < len; i++) {
47.       char c = s.charAt(i);
48.       if (c == '/t') {
49.         do {
50.           sb.append(' ');
51.           pos++;
52.         } while (pos % 8 != 0);
53.       }
54.       else {
55.         sb.append(c);
56.         pos++;
57.       }
58.     }
59.     return sb.toString();
60.   }
61.         
62.   public static String testlist[] = {
63.     "",
64.     "/t",
65.     "/t/t/tabc",
66.     "abc/tdef",
67.     "1234567/t8",
68.     "12345678/t9",
69.     "123456789/t"
70.   };
71.         
72.   public static void main(String args[])
73.   {
74.     for (int i = 0; i < testlist.length; i++) {
75.       String tc = testlist[i];
76.       if (!detab1(tc).equals(detab2(tc)))
77.         System.err.println(tc);
78.      }
79.         
80.      String test_string =
81.        "/t/tthis is a test/tof detabbing performance";
82.      int N = 5000;
83.      int i = 0;
84.         
85.      long ct = System.currentTimeMillis();
86.      for (i = 1; i <= N; i++)
87.        detab1(test_string);
88.      long elapsed = System.currentTimeMillis() - ct;
89.      System.out.println("String time = " + elapsed);
90.          
91.      ct = System.currentTimeMillis();
92.      for (i = 1; i <= N; i++)
93.        detab2(test_string);
94.      elapsed = System.currentTimeMillis() - ct;
95.      System.out.println("StringBuffer time = " 
96.        + elapsed);
97.    }
98. }

執行以上代碼的結果可以看到使用StringBuffer的版本的方法比使用String版本的一般都快十倍以上（本人使用的是JDK1.4.0）,你可以執行一下看看結果到底如何。
因此得到的結論是：如果你對字符串中的內容經常進行操作，特別是內容要修改時，那麼使用StringBuffer，如果最後需要String，那麼使用StringBuffer的toString()方法好了！也許這就是你的程序的性能瓶頸！