Java高效运行必备：如何选择使用String、StringBuffer与StringBuilde

字符串String是Java编程中使用概率最高的变量，也许你觉得没有什么可讲的，随手拈来，然而字符串的处理却尤其需要我们的关注，因为大量的字符串实例的随意创建，给系统的效率带来了很大的问题。
比如下面我们来做一个测试，对比String类和StringBuffer的执行效率：
● String执行10000次累加
long start = System.currentTimeMillis();
String str = "";
for (int i = 0; i < 10000; i++) {
    str += "," + i;
}
long end = System.currentTimeMillis();
System.out.println(end - start);
执行的结果花费了702ms。
● 使用StringBuffer类来代替String类：
long start = System.currentTimeMillis();
StringBuffer str = new StringBuffer();
for (int i = 0; i < 10000; i++) {
    str.append(",").append(i);
}
long end = System.currentTimeMillis();
System.out.println(end - start);
运行共花费了0ms。
通过对比发现StringBuffer几乎不花费时间。这是因为，String对象的每一次累加，都会先将累加的字符串创建一个实例对象然后再累加，等于是创建了10000个实例。而StringBuffer每次都是修改的原有实例对象，只是创建了1个实例。通过学习第2章我们已经知道，创建实例需要申请内存地址、写入数据的过程，大量的这种操作就会消耗大量的CPU计算资源。
也许你会说，StringBuffer这么高效率，那我们不再使用String类就可以了，然而实际情况是，它们在不同的情况下各有选择的优势。通过《高手真经 Java核心编程技术》第11.2节的讲解可知，String、StringBuffer与StringBuilder三者最大的区别是：
● String是字符串常量
● StringBuffer是字符串变量（线程安全）
● StringBuilder是字符串变量（非线程安全）
简要的说，String类型和StringBuffer类型的主要性能区别其实在于，String是不可变的对象，因此在每次对String类型进行改变的时候，其实都等同于生成了一个新的String对象，然后将指针指向新的String对象，所以经常改变内容的字符串最好不要用String，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后，JVM的GC就会开始工作，那速度是一定会相当慢的。
而如果是使用StringBuffer类则结果就不一样了，每次结果都会对StringBuffer对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用StringBuffer，特别是字符串对象经常改变的情况下。而在某些特别情况下，String对象的字符串拼接其实是被JVM解释成了StringBuffer对象的拼接，所以这些时候String对象的速度并不会比StringBuffer对象慢，而特别是以下的字符串对象生成中，String效率是远要比StringBuffer快的：
String str = “This is only a” + “ simple” + “ test”;
StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上：
String str = “This is only a” + “ simple” + “test”;
其实就是：
String str = “This is only a simple test”;
所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：
String str2 = “This is only a”;
String str3 = “ simple”;
String str4 = “ test”;
String str1 = str2 +str3 + str4;
这时候JVM会规规矩矩的按照原来的方式去做。
为了测试这三个类的累加不同次数字符串时的效率，我们编写一个测试类，分别按次数累加字符串：
程序11-8  TestString.java
package test.String;

public class TestString {
   
    static int count = 100;//循环次数
   
// 测试String
    public static void testString() {
        long start = System.nanoTime();
        String str = "";
        for (int i = 0; i < count; i++) {
            str += "," + i;
        }
        long end = System.nanoTime();
        System.out.println("String：" + (end - start));
    }
   
    // 测试StringBuffer
    public static void testStringBuffer() {
        long start = System.nanoTime();
        StringBuffer str = new StringBuffer();
        for (int i = 0; i < count; i++) {
            str.append(",").append(i);
        }
        long end = System.nanoTime();
        System.out.println("StringBuffer：" + (end - start));
    }
   
    // 测试StringBuilder
    public static void testStringBuilder() {
        long start = System.nanoTime();
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < count; i++) {
            str.append(",").append(i);
        }
        long end = System.nanoTime();
        System.out.println("StringBuilder：" + (end - start));
    }

    public static void main(String[] args) {
        TestString.testString();
        TestString.testStringBuffer();
        TestString.testStringBuilder();
    }
}
运行该程序执行的测试时间：
表11-2  测试结果
毫微秒 String StringBuffer StringBuilder
1次 69,562 46,934 8,101
10次 109,791 57,269 24,025
100次 431,619 172,089 128,228
1000次 8,274,236 876,368 270,985
1万次 704,425,841 2,673,524 1,388,166
10万次 溢出 20,926,961 11,669,361
100万次 溢出 246,871,041 137,586,760
String在10w次循环时就溢出了，而StringBuffer在100万次循环时间为246ms，StringBuilder的时间为137ms。显然选择优先级为：StringBuilder>StringBuffer>String。因此，对于这三个类的使用，我们需要按照以下情况去选择：
● 如果你偶尔对简单的字符串常量进行拼接，那么可以使用String，它足够简单而且轻量级；
● 如果你需要经常进行字符串的拼接、累加操作，请使用StringBuffer或StringBuilder；
● 如果是在单线程的环境中，建议使用StringBuilder，它要比StringBuffer快；如果是在多线程的环境中，建议使用StringBuffer，它是线程安全的；
因此，StringBuilder实际上是我们的首选，只有在多线程时才可以考虑使用StringBuffer，只有在字符串的拼接足够简单时才使用String。