String、StringBuffer 与 StringBuilder

String、StringBuffer 与 StringBuilder
0

String、StringBuffer 和 StringBuilder 是 java.lang 包里的3个与字符串密切相关的类,它们都实现了 CharSequence、Comparable 和 Serializable 接口。

在 OpenJRE 的实现中,它们都有一个 byte[] 类型的 value 变量用于存储字符串的编码后的值(encoded value),以及一个 byte 类型的 coder 变量用于指示 value 中存储字符用的是 Latin1 编码还是 UTF-16 编码。

String 是不可变的(immutable);而 StringBuffer 和 StringBuilder 都继承了抽象类 AbstractStringBuilder,都是可变的(mutable)。

StringBuffer 中的绝大多数所有公有的成员方法(public method)都是 synchronized 的,没加 synchronized 的公有方法也是对其他 synchronized 的方法的包装;而StringBuilder 中的方法都不是 synchronized 的。

下面进行更详细的介绍。

1、String

String 是 immutable 的,即除非利用反射强制修改它的值,否则一个 String 对象一旦被创建,其值就不会被修改。

Java 使 String 类为 immutable 的实现方式是:String 类是 final 的,不可以被继承,而且其成员属性(property)都是 private 的,也没有 public 的方法会对字符串的值(String 中的 value 属性进行修改)。

GrepCode 网站上的 OpenJDK 8 中 String 类的实现的截图:

String 的 replace、concat 和 substring 方法,都会返回一个新的 String 对象,而不是对原来的 String 对象进行修改。你可以用如下代码验证这一点:

String a = "aaa";
String b = a.replace("a", "b"); // 不会对a的值产生影响
System.out.println(a == b); // false,b是一个新创建的字符串对象
System.out.println(a); // 此时a还是"aaa"而不是"bbb"

String c = a.concat("cc");
System.out.println(c); // aaacc
System.out.println(a == c); // false,c是一个新创建的字符串对象
System.out.println(a); // 此时a还是"aaa"而不是"aaacc"

String d = a.substring(2);
System.out.println(d); // a
System.out.println(a == d); // false,d是一个新创建的字符串对象
System.out.println(a); // 此时a还是"aaa"而不是"a"

在需要频繁对字符串做修改操作的场景下(最常见的是在字符串后追加内容的场景),如果只用String类提供的方法(如concat方法),则每次字符串操作都会创建一个新的String对象,这样对性能会有影响。例如:

for (int i = 0; i < 1000; i += 1) {
    str = str + arr[i] + ',';
}

如果用String的concat方法来实现,则实际的实现代码会变成:

for (int i = 0; i < 1000; i += 1) {
    str = str.concat(arr[i]).concat(",");
}

这样在1000次循环里,每次都会新创建两个String对象,一共需要创建2000个String对象,这对系统性能会造成影响。

2、StringBuffer

为了应对频繁对字符串做修改操作的场景,Java从JDK1开始就提供了mutable的StringBuffer类。StringBuffer类对外暴露了可以修改其值的append、insert、delete等方法。一个StringBuffer对象在其缓冲区(一个字符数组char[])的容量足够的情况下,调用这些方法可以直接修改StringBuffer的值而不必创建新的对象。(在一个StringBuffer的缓冲区的容量不足的时候,调用其append或者insert就会使StringBuffer创建一个新的更大的缓冲区,这时则会创建一个新的字符数组char[]对象。)

因此,如果上一小节中循环追加内容到字符串的代码改用以下的实际实现,则创建的对象会少很多:

StringBuffer buffer = new StringBuffer(str);
for (int i = 0; i < 1000; i += 1) {
    buffer.append(arr[i]).append(',');
}
str = buffer.toString();

因此在 JDK 1.5 以前,Java编译器都是把字符串 + 字符串那样的代码编译成使用 StringBuffer.append 方法,或者说字符串的加号运算符其实是 StringBuffer.append 的一个语法糖。

3、StringBuilder

那从 JDK 1.5 开始又如何呢?从 JDK 1.5 开始,Java 编译器改用了 StringBuilder。

StringBuilder 类是非线程安全的 StringBuffer 类。即:

StringBuffer buffer = new StringBuffer();
Thread a = new Thread(new Runnable() {
    public void run() {
        buffer.append("aaaaaaaa");
    }
});
Thread b = new Thread(new Runnable() {
    public void run() {
        buffer.append("bbbbbbbb");
    }
});
a.start(); b.start();
a.join(); b.join();
System.out.println(buffer.toString());
// 要不就是 aaaaaaaabbbbbbbb,要不就是 bbbbbbbbaaaaaaaa

StringBuilder builder = new StringBuilder();
a = new Thread(new Runnable() {
    public void run() {
        builder.append("aaaaaaaa");
    }
});
b = new Thread(new Runnable() {
    public void run() {
        builder.append("bbbbbbbb");
    }
});
a.start(); b.start();
a.join(); b.join();
System.out.println(builder.toString());
// 这时候情况就复杂多了,有可能 a 线程追加a的过程执行到一般被系统暂停,然后系统调度 b 线程执行,这样的话结果就可能是 aaaabbbbbbbbaaaa

为了实现线程安全,StringBuffer 在 insert、append、delete 这些 public 方法的定义处加了synchronized关键字:

但是,实际应用时,对字符串追加内容的操作几乎都是在一个线程中进行的(例如最开始的循环向字符串追加内容的代码),这样如果用 StringBuffer 的话,就会额外有给 StringBuffer 对象加锁的开销。因此从 JDK 1.5 开始,编译器改为了使用 StringBuilder 来实现字符串 + 字符串的操作,即字符串的加号运算符的变成了 StringBuilder.append 的语法糖。

1赞