public class TestStringBuffereBuillder {
        final static int NUM = 100000000;
        public static void main(String[] args) {
                //测试的次数
                for (int j = 0; j < 5; j++) {
                        System.out.print(j+" ");
                        testString();
                        testStringBuffere();
                        testStringBuilder();
                }
               
        }
        public static void testString(){
                String string = "mmmmxxxxyy";
                long startTime = System.currentTimeMillis();
                for (int i = 0; i < NUM; i++) {
                        //String类中的方法，用于在String后连接字符串
                        string.concat("88");
                        //截取新的字符串
                        string = string.substring(0, 10);
                }
                long endTime = System.currentTimeMillis();
                System.out.print((endTime - startTime) + "ms   ");
        }
        public static void testStringBuffere(){
                StringBuffer stringBuffer = new StringBuffer("mmmmxxxxyy");
                long startTime1 = System.currentTimeMillis();
                for (int i = 0; i < NUM; i++) {
                        //StringBuffer与StringBuillder中的方法，末尾添加字符串与删除制定位置的字符串
                        stringBuffer.append("88");
                        stringBuffer = stringBuffer.delete(10, 12);
                }
                long endTime1 = System.currentTimeMillis();
                System.out.print((endTime1 - startTime1) + "ms  ");
        }
        public static void testStringBuilder(){
                StringBuilder stringBuilder = new StringBuilder("mmmmxxxxyy");
                long startTime1 = System.currentTimeMillis();
                for (int i = 0; i < NUM; i++) {
                        stringBuilder.append("88");
                        stringBuilder = stringBuilder.delete(10, 12);
                }
                long endTime1 = System.currentTimeMillis();
                System.out.println((endTime1 - startTime1) + "ms");
        }
}
输出结果


     可以看到，在大量对字符串的操作的情况下，String的效率要低得多。String是不可变的对象, 因此在每次对String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，性能就会降低。
      而StringBuffere和StringBuilder之间相差的不是太大。使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。所以多数情况下推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。

     基本原则：如果要操作少量的数据，用String ；单线程操作大量数据，用StringBuilder ；多线程操作大量数据，用StringBuffere。

1. package itHeima.RUXUE2;
   
2. 
   
3. import org.junit.Test;
   
4. 
   
5. public class Test16 {
   
6.         private final int time = 20000;
   
7. 
   
8.         @Test
   
9.         public void test(){
   
10.                 test_String();
    
11.                 test_StringBuffer();
    
12.                 test_StringBuilder();
    
13.                
    
14.         }
    
15.        
    
16.         //测试String类的增删效率
    
17.         public void test_String(){
    
18.                 long startTime = myAdvice.getStart();
    
19.                 String str = "ABCDE";
    
20.                 for(int i = 0; i<time; i++){
    
21.                         str = str +"!";
    
22.                         str = str.substring(0, i);
    
23.                 }
    
24.                 long endTime = myAdvice.getEnd();
    
25.                 System.out.println("String类的花费时间为："+(endTime-startTime));
    
26.         }
    
27.         //测试StringBuffer的增删效率
    
28.         public void test_StringBuffer(){
    
29.                 long startTime = myAdvice.getStart();
    
30.                 StringBuffer str = new StringBuffer("ABCDE");
    
31.                 for(int i = 0; i<time; i++){
    
32.                         str.append("!");
    
33.                         str = new StringBuffer(str.substring(0, i));
    
34.                 }
    
35.                 long endTime = myAdvice.getEnd();
    
36.                 System.out.println("StringBuffer类的花费时间为："+(endTime-startTime));
    
37.         }
    
38.         //测试StringBuilder的增删效率
    
39.         public void test_StringBuilder() {
    
40.                 long startTime = myAdvice.getStart();
    
41.                 StringBuilder str = new StringBuilder("ABCDE");
    
42.                 for (int i = 0; i < time; i++) {
    
43.                         str.append("!");
    
44.                         str = new StringBuilder(str.substring(0, i));
    
45.                 }
    
46.                 long endTime = myAdvice.getEnd();
    
47.                 System.out.println("StringBuilder类的花费时间为：" + (endTime - startTime));
    
48.         }
    
49.        
    
50. }
    
51. class myAdvice{
    
52.         public static long getStart(){
    
53.                 return System.currentTimeMillis();
    
54.         }
    
55.         public static long getEnd(){
    
56.                 return System.currentTimeMillis();
    
57.         }
    
58. }
    

复制代码

我也写了一个，不过效果不是很明显，相差的时间并不多，StringBuilder时间用时最少

贾浩田 发表于 2014-10-27 21:00
我也写了一个，不过效果不是很明显，相差的时间并不多，StringBuilder时间用时最少 ...

次数太少了。数量少看不到效果