String、StringBuilder和StringBuffer

String类，StringBuilder和StringBuffer类有许多相似之处，对于其中的异同之处需仔细琢磨。

1. 性质

String 是只读字符串，也就意味着 String 引用的字符串内容是不能被改变的。初学者可能会有这样的误解：
1
2
String str = “abc”；
str = “bcd”;
如上，字符串 str 明明是可以改变的呀！其实不然， str 仅仅是一个引用对象，它指向一个字符串对象“abc”。第二行代码的含义是让 str 重新指向了一个新的字符串“bcd”对象，而“abc”对象并没有任何改变，只不过该对象已经成为一个不可及对象罢了。
StringBuffer/StringBuilder表示的字符串对象可以直接进行修改。其中StringBuilder 是 Java5 中引入的，它和 StringBuffer 的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方法都没有被 synchronized 修饰，因此它的效率理论上比StringBuffer 要高

2. 字符串拼接

String类提供了字符串之间的拼接符号“+”，可以用来字符串之间的拼接。比如：

1	String str = "abc" + "123";

当然，StringBuilder类也提供用于字符串拼接的方法append。

下面我们来研究“+”与append方法之间异同：

public class MyDemo {
    public static void main(String[] args) {
        String s = "abc";
        String ss = "ok" + s + "xyz" + 5;
        System.out.println(ss);
    }
}

使用Jad根据进行反编译的结果如下（命令：jad -o -a -s d.java MyDemo.class）:

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) annotate 
// Source File Name:   MyDemo.java

import java.io.PrintStream;

public class MyDemo
{
    public MyDemo()
    {
    //    0    0:aload_0         
    //    1    1:invokespecial   #1   <Method void Object()>
    //    2    4:return          
    }

    public static void main(String args[])
    {
        String s = "abc";
    //    0    0:ldc1            #2   <String "abc">
    //    1    2:astore_1        
        String s1 = (new StringBuilder()).append("ok").append(s).append("xyz").append(5).toString();
    //    2    3:new             #3   <Class StringBuilder>
    //    3    6:dup             
    //    4    7:invokespecial   #4   <Method void StringBuilder()>
    //    5   10:ldc1            #5   <String "ok">
    //    6   12:invokevirtual   #6   <Method StringBuilder StringBuilder.append(String)>
    //    7   15:aload_1         
    //    8   16:invokevirtual   #6   <Method StringBuilder StringBuilder.append(String)>
    //    9   19:ldc1            #7   <String "xyz">
    //   10   21:invokevirtual   #6   <Method StringBuilder StringBuilder.append(String)>
    //   11   24:iconst_5        
    //   12   25:invokevirtual   #8   <Method StringBuilder StringBuilder.append(int)>
    //   13   28:invokevirtual   #9   <Method String StringBuilder.toString()>
    //   14   31:astore_2        
        System.out.println(s1);
    //   15   32:getstatic       #10  <Field PrintStream System.out>
    //   16   35:aload_2         
    //   17   36:invokevirtual   #11  <Method void PrintStream.println(String)>
    //   18   39:return          
    }
}

从上面的代码很容易看出，虽然在源程序中使用了”+”，但在编译时仍然将”+”转换成 StringBuilder。因此，我们可以得出结论，在 Java 中无论使用何种方式进行字符串连接，实际上都使用的是 StringBuilder。

那么是不是可以根据这个结论推出使用”+”和 StringBuilder 的效果是一样的呢？这个要从两个方面的解释。如果从运行结果来解释，那么”+”和 StringBuilder 是完全等效的。但如果从运行效率和资源消耗方面看，那它们将存在很大的区别。
当然，如果连接字符串行表达式很简单（如上面的顺序结构），那么”+”和 StringBuilder 基本是一样的，但如果结构比较复杂，如使用循环来连接字符串，那么产生的 Java Byte Code 就会有很大的区别。先让我们看看如下的代码：

public class MyDemo {
    public static void main(String[] args) {
        String s = "";
        Random rand = new Random();
        for (int i = 0; i < 10; i++) {
            s = s + rand.nextInt(1000) + " ";
        }
        System.out.println(s);
    }
}

反编译结果如下：

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) annotate 
// Source File Name:   MyDemo.java

import java.io.PrintStream;
import java.util.Random;

public class MyDemo
{

    public MyDemo()
    {
    //    0    0:aload_0         
    //    1    1:invokespecial   #1   <Method void Object()>
    //    2    4:return          
    }

    public static void main(String args[])
    {
        String s = "";
    //    0    0:ldc1            #2   <String "">
    //    1    2:astore_1        
        Random random = new Random();
    //    2    3:new             #3   <Class Random>
    //    3    6:dup             
    //    4    7:invokespecial   #4   <Method void Random()>
    //    5   10:astore_2        
        for(int i = 0; i < 10; i++)
    //*   6   11:iconst_0        
    //*   7   12:istore_3        
    //*   8   13:iload_3         
    //*   9   14:bipush          10
    //*  10   16:icmpge          55
            s = (new StringBuilder()).append(s).append(random.nextInt(1000)).append(" ").toString();
    //   11   19:new             #5   <Class StringBuilder>
    //   12   22:dup             
    //   13   23:invokespecial   #6   <Method void StringBuilder()>
    //   14   26:aload_1         
    //   15   27:invokevirtual   #7   <Method StringBuilder StringBuilder.append(String)>
    //   16   30:aload_2         
    //   17   31:sipush          1000
    //   18   34:invokevirtual   #8   <Method int Random.nextInt(int)>
    //   19   37:invokevirtual   #9   <Method StringBuilder StringBuilder.append(int)>
    //   20   40:ldc1            #10  <String " ">
    //   21   42:invokevirtual   #7   <Method StringBuilder StringBuilder.append(String)>
    //   22   45:invokevirtual   #11  <Method String StringBuilder.toString()>
    //   23   48:astore_1        

    //   24   49:iinc            3  1
    //*  25   52:goto            13
        System.out.println(s);
    //   26   55:getstatic       #12  <Field PrintStream System.out>
    //   27   58:aload_1         
    //   28   59:invokevirtual   #13  <Method void PrintStream.println(String)>
    //   29   62:return          
    }
}

可以看到，虽然编译器将”+”转换成了 StringBuilder，但创建 StringBuilder 对象的位置却在 for 语句内部。这就意味着每执行一次循环，就会创建一个 StringBuilder 对象（对于本例来说，是创建了 10 个 StringBuilder对象），虽然 Java 有垃圾回收器，但这个回收器的工作时间是不定的。如果不断产生这样的垃圾，那么仍然会占用大量的资源。

推荐使用如下方式编写代码：

import java.util.*;

public class MyDemo {
    public static void main(String[] args) {
        String s = "";
        Random rand = new Random();
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < 10; i++) {
           result.append(rand.nextInt(1000));
           result.append(" ");
        }
        System.out.println(result.toString());
    }
}

反编译的结果如下：

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) annotate 
// Source File Name:   MyDemo.java

import java.io.PrintStream;
import java.util.Random;

public class MyDemo
{

    public MyDemo()
    {
    //    0    0:aload_0         
    //    1    1:invokespecial   #1   <Method void Object()>
    //    2    4:return          
    }

    public static void main(String args[])
    {
        String s = "";
    //    0    0:ldc1            #2   <String "">
    //    1    2:astore_1        
        Random random = new Random();
    //    2    3:new             #3   <Class Random>
    //    3    6:dup             
    //    4    7:invokespecial   #4   <Method void Random()>
    //    5   10:astore_2        
        StringBuilder stringbuilder = new StringBuilder();
    //    6   11:new             #5   <Class StringBuilder>
    //    7   14:dup             
    //    8   15:invokespecial   #6   <Method void StringBuilder()>
    //    9   18:astore_3        
        for(int i = 0; i < 10; i++)
    //*  10   19:iconst_0        
    //*  11   20:istore          4
    //*  12   22:iload           4
    //*  13   24:bipush          10
    //*  14   26:icmpge          54
        {
            stringbuilder.append(random.nextInt(1000));
    //   15   29:aload_3         
    //   16   30:aload_2         
    //   17   31:sipush          1000
    //   18   34:invokevirtual   #7   <Method int Random.nextInt(int)>
    //   19   37:invokevirtual   #8   <Method StringBuilder StringBuilder.append(int)>
    //   20   40:pop             
            stringbuilder.append(" ");
    //   21   41:aload_3         
    //   22   42:ldc1            #9   <String " ">
    //   23   44:invokevirtual   #10  <Method StringBuilder StringBuilder.append(String)>
    //   24   47:pop             
        }

    //   25   48:iinc            4  1
    //*  26   51:goto            22
        System.out.println(stringbuilder.toString());
    //   27   54:getstatic       #11  <Field PrintStream System.out>
    //   28   57:aload_3         
    //   29   58:invokevirtual   #12  <Method String StringBuilder.toString()>
    //   30   61:invokevirtual   #13  <Method void PrintStream.println(String)>
    //   31   64:return          
    }
}

从上面的反编译结果可以看出，创建 StringBuilder 的代码被放在了 for 语句外。虽然这样处理在源程序中看起来复杂，但却换来了更高的效率，同时消耗的资源也更少了。

在使用 StringBuilder 时要注意，尽量不要”+”和 StringBuilder 混着用，否则会创建更多的 StringBuilder 对象，如下面代码所示：

for (int i = 0; i < 10; i++) {
    result.append(rand.nextInt(1000));
    result.append(" ");
}

将上方的代码改为如下形式：

1	result.append(rand.nextInt(1000) + " "); // +与append混用

反编译结果如下：

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) annotate 
// Source File Name:   MyDemo.java

import java.io.PrintStream;
import java.util.Random;

public class MyDemo
{

    public MyDemo()
    {
    //    0    0:aload_0         
    //    1    1:invokespecial   #1   <Method void Object()>
    //    2    4:return          
    }

    public static void main(String args[])
    {
        String s = "";
    //    0    0:ldc1            #2   <String "">
    //    1    2:astore_1        
        Random random = new Random();
    //    2    3:new             #3   <Class Random>
    //    3    6:dup             
    //    4    7:invokespecial   #4   <Method void Random()>
    //    5   10:astore_2        
        StringBuilder stringbuilder = new StringBuilder();
    //    6   11:new             #5   <Class StringBuilder>
    //    7   14:dup             
    //    8   15:invokespecial   #6   <Method void StringBuilder()>
    //    9   18:astore_3        
        for(int i = 0; i < 10; i++)
    //*  10   19:iconst_0        
    //*  11   20:istore          4
    //*  12   22:iload           4
    //*  13   24:bipush          10
    //*  14   26:icmpge          65
    //	 此处产生StringBuilder对象
            stringbuilder.append((new StringBuilder()).append(random.nextInt(1000)).append(" ").toString()); 
    //   15   29:aload_3         
    //   16   30:new             #5   <Class StringBuilder>
    //   17   33:dup             
    //   18   34:invokespecial   #6   <Method void StringBuilder()>
    //   19   37:aload_2         
    //   20   38:sipush          1000
    //   21   41:invokevirtual   #7   <Method int Random.nextInt(int)>
    //   22   44:invokevirtual   #8   <Method StringBuilder StringBuilder.append(int)>
    //   23   47:ldc1            #9   <String " ">
    //   24   49:invokevirtual   #10  <Method StringBuilder StringBuilder.append(String)>
    //   25   52:invokevirtual   #11  <Method String StringBuilder.toString()>
    //   26   55:invokevirtual   #10  <Method StringBuilder StringBuilder.append(String)>
    //   27   58:pop             

    //   28   59:iinc            4  1
    //*  29   62:goto            22
        System.out.println(stringbuilder.toString());
    //   30   65:getstatic       #12  <Field PrintStream System.out>
    //   31   68:aload_3         
    //   32   69:invokevirtual   #11  <Method String StringBuilder.toString()>
    //   33   72:invokevirtual   #13  <Method void PrintStream.println(String)>
    //   34   75:return          
    }
}

从上面的代码可以看出， Java 编译器将”+”编译成了 StringBuilder，这样 for 语句每循环一次，又创建了一个StringBuilder 对象。

3. String常量池相关

1 2	String str = "abc"; //创建一个字符串对象在字符串常量池中 String s = new String("abc"); //创建两个对象，一个new（存储引用），一个字符串对象在堆内存中。

相关问题：
在这里插入图片描述

String 对象的 intern（）方法会得到字符串对象在常量池中对应的版本的引用（如果常量池中有一个字符串与String 对象的 equals 结果是 true），如果常量池中没有对应的字符串，则该字符串将被添加到常量池中，然后返回常量池中字符串的引用；
String s6 = s3 + s4;中的对象s6是在运行期间创建，这条语句所创建的”Programing”字符串作为String对象存储在内存中的一个独立位置。