String、StringBuffer、StringBuilder 性能测试

这几个时常用于比较，我们通过实验来分析其性能，然后试图去寻找背后的原因。

实验总的代码：

public class Test {    final static int NUM = 100000;    public static void testString(String str){        long start = System.currentTimeMillis();        for(int i=0; i<NUM; i++){            str += "append-";        }        long end = System.currentTimeMillis();        System.out.println(str.getClass().getName() + " 共占用了 ：  "+  (end-start) + " 毫秒");    }    public static void testString(StringBuffer str){        long start = System.currentTimeMillis();        for(int i=0; i<NUM; i++){            str.append("append-") ;        }        long end = System.currentTimeMillis();        System.out.println(str.getClass().getName() + " 共占用了 ：  "+  (end-start) + " 毫秒");    }    public static void testString(StringBuilder str){        long start = System.currentTimeMillis();        for(int i=0; i<NUM; i++){            str.append("append-");        }        long end = System.currentTimeMillis();        System.out.println(str.getClass().getName() + " 共占用了 ：  "+  (end-start) + " 毫秒");    }  //字符串對象引用相加    public static void testStringAppend(){        String str = "abc";        long start = System.currentTimeMillis();        for(int i=0; i<NUM; i++){            String newStr = str+ str+ str;        }        long end = System.currentTimeMillis();        System.out.println("字符串对象引用相加类型使用的时间为： " + " 共占用了 ：  "+  (end-start) + " 毫秒");    }    //字符串直接相加    public static void testStringAdd(){        long start = System.currentTimeMillis();        for(int i=0; i<NUM; i++){            String newStr = "abc"+ "abc" + "abc";        }        long end = System.currentTimeMillis();        System.out.println("字符串相加：  " + " 共占用了 ：  "+  (end-start) + " 毫秒");    }    public static void main(String[] args) {         String s= "asdf";         StringBuffer sbf = new StringBuffer("asdf");         StringBuilder sbd = new StringBuilder("asdf");         Test.testString(s);          （1）         Test.testString(sbf);         （2）         Test.testString(sbd);          （3）         Test.testStringAdd();           （4）         Test.testStringAppend();          （5）    }}结果：java.lang.String 共占用了 ：         26996 毫秒java.lang.StringBuffer 共占用了 ：   6 毫秒java.lang.StringBuilder 共占用了 ：  4 毫秒字符串相加：   共占用了 ：             1 毫秒字符串对象引用相加类型使用的时间为：  共占用了 ：  13 毫秒

具体分析：

1、执行（1）所花时间最长，是其他的上万倍，可见其性能不大好哇。
原因分析：我们可以通过一次小实验来分析其原因。

public class TestSmaller {    public static void main(String[] args) {        String str1 = "append-";        String str2 = "asdf-";        String str3 = "append-"+"asdf-" ;        String str4 = str1 + str2;        System.out.println(str4.equals(str3) +"  其內容是：    "+ str3);        System.out.println(str3 == str4);        System.out.println(str3.hashCode());        System.out.println(str4.hashCode());    }}输出结果：true  其內容是：    append-asdf-false210131462210131462

从上面可知，str3 与 str4 其实是两个不同的对象（String 重写了hashcode() 和 equals() 方法，所以 输出的hashcode必然是一样的）。所以，也就是说，每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象。所以，当不断循环时，之前的 string对象将不在被引用，会触发JVM的GC，所以速度慢。

2、执行（2）的时候，从代码 str.append(“append-“); 也可以看出 ，是在原来对象的做值的修改，而且是县城安全的：

public synchronized StringBuffer append(String str) {        super.append(str);        return this;    }而super.append(str);  指的是基类中public AbstractStringBuilder append(String str) {        if (str == null) str = "null";        int len = str.length();        ensureCapacityInternal(count + len);        str.getChars(0, len, value, count);        count += len;        return this;    }

3、执行（3）中的时候，与（2）中几乎无差异，只是它不是线程安全的，所以稍微快点：

    public StringBuilder append(String str) {        super.append(str);        return this;    }

4、执行（4）中所花的时间几乎就是for() 所花费的时间，应为 newStr只要执行一次 就可以了。

5、执行（5）时，每次都要去str所指向的地址找到相应的值，然后做拼接，所以花费的时间是（4）的数倍。

结论：
1、性能方面：
StringBuilder >(略大于) StringBuffer >>(远大于) String；
2、StringBuffer 是线程安全的、可变；
3、经常改变内容的字符串最好不用 String 类型。