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-
false
210131462
210131462

从上面可知，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 类型。