String、StringBuilder和StringBuffer
String类，StringBuilder和StringBuffer类有许多相似之处，对于其中的异同之处需仔细琢磨。
性质
-
String 是只读字符串，也就意味着 String 引用的字符串内容是不能被改变的。 初学者可能会有这样的误解：
String str = “abc”； str = “bcd”;如上，字符串 str 明明是可以改变的呀！其实不然， str 仅仅是一个引用对象，它指向一个字符串对象“abc”。第二行代码的含义是让 str 重新指向了一个新的字符串“bcd”对象，而“abc”对象并没有任何改变，只不过该对象已经成为一个不可及对象罢了。
-
StringBuffer/StringBuilder表示的字符串对象可以直接进行修改。其中StringBuilder 是 Java5 中引入的，它和 StringBuffer 的方法完全相同，区别在于它是在单线程环境下使用的，因为它的所有方法都没有被 synchronized 修饰，因此它的效率理论上比StringBuffer 要高
字符串拼接
String类提供了字符串之间的拼接符号“+”，可以用来字符串之间的拼接。比如：
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(" ");
}
将上方的代码改为如下形式：
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 对象。
String常量池相关
String str = "abc"; //创建一个字符串对象在字符串常量池中
String s = new String("abc"); //创建两个对象，一个new（存储引用），一个字符串对象在堆内存中。
相关问题：
- String 对象的 intern（）方法会得到字符串对象在常量池中对应的版本的引用（如果常量池中有一个字符串与String 对象的 equals 结果是 true），如果常量池中没有对应的字符串，则该字符串将被添加到常量池中，然后返回常量池中字符串的引用；
- String s6 = s3 + s4;中的对象s6是在运行期间创建，这条语句所创建的"Programing"字符串作为String对象存储在内存中的一个独立位置。