String StringBuffer StringBuilder

转载：http://www.cnblogs.com/fancydeepin/archive/2013/04/23/min-snail-speak_String-StringBuffer-StringBuilder.html

三个类的异同点：

1) 都是 final 类, 都不允许被继承;

2) String 长度是不可变的, StringBuffer、StringBuilder 长度是可变的;

3) StringBuffer 是线程安全的, StringBuilder 不是线程安全的。

没错，String 字符串是常量, 它们的值在创建之后不能够被更改，虽然可以用+号进行字符串拼接，但底层实际上是需要另外开拓空间的，例子说明如下：

package net.yeah.fancydeepin.string;

public class Application {

    public static void main(String[] args) {
        
        String str = "abc";
        str += "cde";
        System.out.println(str);
    }
}

当程序运行时, JVM 内存中的分配看起来应该像:

从上面的图来看, str 最初引用的是 "abc" 对象, 最终打印输出的结果是 abccde, 这并不是说 str 所引用的对象的内容发生了变化,

而是 str 在执行的过程中重新引用了另外的一个 String 对象 "abccde"。

串联字条串的性能测试

代码如下：

public class Application {

    private final int LOOP_TIMES = 200000;
    private final String CONSTANT_STRING = "min-snail";
    
    public static void main(String[] args) {
        
        new Application().startup();
    }
    
    public void testString(){
        String string = "";
        long beginTime = System.currentTimeMillis();
        for(int i = 0; i < LOOP_TIMES; i++){
            string += CONSTANT_STRING;
        }
        long endTime = System.currentTimeMillis();
        System.out.print("String : " + (endTime - beginTime) + "	");
    }
    
    public void testStringBuffer(){
        StringBuffer buffer = new StringBuffer();
        long beginTime = System.currentTimeMillis();
        for(int i = 0; i < LOOP_TIMES; i++){
            buffer.append(CONSTANT_STRING);
        }
        buffer.toString();
        long endTime = System.currentTimeMillis();
        System.out.print("StringBuffer : " + (endTime - beginTime) + "	");
    }
    
    public void testStringBuilder(){
        StringBuilder builder = new StringBuilder();
        long beginTime = System.currentTimeMillis();
        for(int i = 0; i < LOOP_TIMES; i++){
            builder.append(CONSTANT_STRING);
        }
        builder.toString();
        long endTime = System.currentTimeMillis();
        System.out.print("StringBuilder : " + (endTime - beginTime) + "	");
    }
    
    public void startup(){
        for(int i = 0; i < 6; i++){
            System.out.print("The " + i + " [	    ");
            testString();
            testStringBuffer();
            testStringBuilder();
            System.out.println("]");
        }
    }
}

上面示例是频繁的去串联一个比较短的字符串, 然后反复调 6 次。下面附上具体数据:

　　从表格数据可以看出, 使用 String 的 "+" 符号串联字符串的性能差的惊人, 大概会维持在 3分40秒的时候可以看到一次打印结果;

其次是 StringBuffer, 平均花时 9.2 毫秒; 然后是 StringBuilder, 平均花时 7.5 毫秒。

　　1）String的性能之所以这么差，是因为底层将循环体内的 string += CONSTANT_STRING; 语句转成了:

string = (new StringBuilder(String.valueOf(string))).append("min-snail").toString();

　　所以在二十万次的串联字符串中, 每一次都先去创建 StringBuilder 对象, 然后再调 append() 方法来完成 String 类的 "+" 操作。

这里的大部分时间都花在了对象的创建上, 而且每个创建出来的对象的生命都不能长久, 朝生夕灭, 因为这些对象创建出来之后没有引用变量来引用它们,

那么它们在使用完成时候就处于一种不可到达状态, java 虚拟机的垃圾回收器(GC)就会不定期的来回收这些垃圾对象。

　但如果是遇到如下情况:

String concat1 = "I" + " am " + "min-snail";
 
String concat2 = "I";
concat2 += " am ";
concat2 += "min-snail";

　　java 对 concat1 的处理速度也是快的惊人。本人在自己的笔记本上测试多次, 耗时基本上都是 0 毫秒。这是因为 concat1 在编译期就可以被确定是一个字符常量。

当编译完成之后 concat1 的值其实就是 "I am min-snail", 因此, 在运行期间自然就不需要花费太多的时间来处理 concat1 了。如果是站在这个角度来看, 使用

StringBuilder 完全不占优势, 在这种情况下, 如果是使用 StringBuilder 反而会使得程序运行需要耗费更多的时间。

但是 concat2 不一样, 由于 concat2 在编译期间不能够被确定, 因此, 在运行期间 JVM 会按老一套的做法, 将其转换成使用 StringBuilder 来实现。　　

　　2）从表格数据可以看出, StringBuilder 与 StringBuffer 在耗时上并不相差多少, 只是 StringBuilder 稍微快一些, 但是 StringBuilder 是

冒着多线程不安全的潜在风险。这也是 StringBuilder 为赚取表格数据中的 1.7 毫秒( 若按表格的数据来算, 性能已经提升 20% 多 )所需要付出的代价。

　　3) 综合来说:

　　StringBuilder 是 java 为 StringBuffer 提供的一个等价类, 但不保证同步。在不涉及多线程的操作情况下可以简易的替换 StringBuffer 来提升

系统性能; StringBuffer 在性能上稍略于 StringBuilder, 但可以不用考虑线程安全问题; String 的 "+" 符号操作起来简单方便,

String 的使用也很简单便捷, java 底层会转换成 StringBuilder 来实现, 特别如果是要在循环体内使用, 建议选择其余两个。

程序猿必读