使用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()方法好了！也许这就是你的程序的性能瓶颈！