常用String字符串拼接的性能比较与分析

平时编写代码的过程中，免不了String字符串的拼接，特别是需要拼接SQL语句的时候

本人平时用的比较多的方式有

1：String1 + String2

2：StringBuffer

3：String1.concat(String2)

为了放大性能差距

每种方式循环十万次

方式1：

            @Test
	    public void testPlus() {
	        String s = "";
	        long ts = System.currentTimeMillis();
	        for (int i = 0; i < 100000; i++) {
	            s = s + i;
	        }
	        long te = System.currentTimeMillis();
	        System.out.println("String1+String2:" + (te - ts));
	    }

控制台输出结果为：

String1+String2:15160。可见性能及其差，不过用的非常方便。

方式2：

            @Test
	    public void testStringBuffer() {
	        StringBuffer sb = new StringBuffer();
	        long ts = System.currentTimeMillis();
	        for (int i = 0; i < 100000; i++) {
	            sb.append(i);
	        }
	        sb.toString();
	        long te = System.currentTimeMillis();
	        System.out.println("StringBuffer:" + (te - ts));
	    }

控制台输出结果为：

StringBuffer：31。性能极强，但是没有 方式1 好用。

既然有StringBuffer拼接，那么肯定不能少了 StringBuilder

	    @Test
	    public void testStringBuilder() {
	        StringBuilder sb = new StringBuilder();
	        long ts = System.currentTimeMillis();
	        for (int i = 0; i < 100000; i++) {
	            sb.append(i);
	        }
	        sb.toString();
	        long te = System.currentTimeMillis();
	        System.out.println("StringBuilder:" + (te - ts));
	    }

控制台输出结果：15。因为是线程不安全的，性能优先，所以性能比StringBuffer还要快不少。

方式3：

	    @Test
	    public void testConcat() {
	        String s = "";
	        long ts = System.currentTimeMillis();
	        for (int i = 0; i < 100000; i++) {
	            s = s.concat(i + "");
	        }
	        long te = System.currentTimeMillis();
	        System.out.println("String1.concat(String2):" + (te - ts));
	    }

控制台输出结果：

String1.concat(String2)：6327。性能上比 方式1 好了不少，但还是与 方式2 差距巨大。

总结：

String1 + String2 这种方式的性能最差，但是用起来简单，可阅读性也是最高的。

StringBuffer与StringBuilder，性能极强，操作起来没有上面的方式简单。

String1.Concat(String2)方式性能比不上StringBuffer，易用性比不上 String1 + String2，感觉好鸡肋。

分析：

String1 = String1 + String2 底层是StringBuffer实现的

相当于 String1 = new StringBuilder(String1 ).append(String2).toString();

执行一次，除了原来的 String1 和 String2,

还会产生一个StringBuffer对象，调用toString()后，又产生一个新的String字符串对象。

StringBuffer底层是由 字符数组 实现的，调用append()方法的时候，只是加长数组长度，拷贝等基本的操作，

并没有产生新的对象，只是在最后调用toString()的时候，产生一个String对象返回。所以性能极高。

String1.concat(String2)方式

底层原理是将 String1和String2转换为 两个 字符数组，

然后再把两个字符数组拼接在一起，拼接完成之后，然后再 new String(新字符数组[],true)，创建一个新的字符串对象。

每次调用concat()都会新生成一个String对象。

新生成的对象比 String1 + String2少，所以性能较高，但是与StringBuffer相比，还是差一大截。