解析Java中的String、StringBuilder、StringBuffer类（一）

引言

String 类及其相关的StringBuilder、StringBuffer 类在 Java 中的使用相当的多，在各个公司的面试中也是必不可少的。因此，在本周，我打算花费一些时间来认真的研读一下 String、StringBuilder、StringBuffer类 的相关代码。

String的不可变性

这个特性是 String 相当重要的一个特性，为了深入理解，我直接贴上其源代码

public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len);
return new String(buf, true);
}
public String replace(char oldChar, char newChar) {
if (oldChar != newChar) {
int len = value.length;
int i = -1;
char[] val = value; /* avoid getfield opcode */

while (++i < len) {
if (val[i] == oldChar) {
break;
}
}
if (i < len) {
char buf[] = new char[len];
for (int j = 0; j < i; j++) {
buf[j] = val[j];
}
while (i < len) {
char c = val[i];
buf[i] = (c == oldChar) ? newChar : c;
i++;
}
return new String(buf, true);
}
}
return this;
}
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
.....

通过以上几个方法的代码，我们可以得出以下的结论：

String 对象时不可变的。所谓不可变的意思是说我们使用的很多方法来对字符串进行修改,如以下所示：

public static void main(String[] args) {
String str = "test";
str = str + "a";
System.out.println(str);//testa
str += "b";
System.out.println(str);//testab
}

诸如上面的 + 号和 concat, replace 等看起来会改变 String 值的方法，其最终都是创建了一个全新的 String 对象，用来包含修改后的字符串内容。str 最先指向的对象 “test” 一直呆在原物理位置上。各个方法操作的其实是复制的一份引用，返回的是一个新的对象，以上例子的原 “test” 还在原始处。

一些误区：String 的不可变性并不是因为下面的语句

private final char value[];

final 在引用类型中，只是确保了不能指向其它引用，而不能确保引用的更改。value 是 private 的， 虽然 String 没有提供更改value的方法，但通过反射可将其更改。

String的 + 与 += 符号

众所周知， C++ 是可以重载操作符的， 但 Java 并不允许程序员对操作符进行重载，而String的 + 与 += 符号却违反了这个规则。我们都知道，Java 中的这两个操作符都是对字符串进行拼接，看一下以下的代码：

class Test{
public static void main(String[] args){
String str = "a";
str +="hello" + "world" + "!";
System.out.println(str);//ahelloworld!

String pStr = "a" + str + "b";
System.out.println(pStr);//aahelloworld!b
}
}

如符按照我们理解的 String 的不可变性，那么在多次进行 + 操作时，应该会在最终的结果之前生成多个中间的文件，那么事实真的是这样子吗？如果是这样子想一下就知道效率和性能有多糟糕了。我们对代码进行反编译。

javap -c Test

其产生了如下的 JVM 字节码：



我们可以看到，在以上的代码中， 编译器为我们自动的引入了 java.lang.StringBuilder 类， 并使用了该类的 append(String str) 这个方法， 最终使用 toString() 产生 String 字符串并进行了赋值。

「循环」中拼接字符串不要使用 String

那么，我们是不是可以愉快的使用 + 和 += 这两个操作符了呢？ NO! 编译器所能做的也是有限的。

public class Test {
public static void main(String[] args) {
String s = "";
long start = System.currentTimeMillis();
for (int i = 0; i <100000 ; i++) {
s += "a";
}
long end = System.currentTimeMillis();
System.out.println("String time:"+ (end - start));

StringBuilder sb = new StringBuilder("");
long start2 = System.currentTimeMillis();
for (int i = 0; i <100000 ; i++) {
sb.append("a");
}
long end2 = System.currentTimeMillis();
System.out.println("StringBuilder time:"+ (end2 - start2));
}
}

在以上的代码中， 输出是这样子的, 我还去掉了中间装载类所花费的时间：

String time:2573
StringBuilder time:5

为什么差距这么大呢？

同样的，我们对这个文件进行反编译，第一个循环的字节码如下：



可以看出 10 到 40 就是我们的循环体了，在该循环体中，有一个 new 的操作，这意味着每次进行循环时，都会创建一个 StringBuilder 的对象，每次都使用一次 toString() 方法。而这些过程都是相当的影响性能的。

而第二个循环的字节码如下：



从以上我们可以看出，循环是从 95 到 113 行，而这个过程中，始终只有一个 StringBuilder 的对象， 也就是说它没有产生新的对象， 可想而知两个之间的性能是怎么产生差异的了。

因此，「循环」中拼接字符串不要使用 String， 这个在写 toString() 方法时可能会遇到。

好，今天我们就分析到这里，下篇文章再会。

另，转载请注明出处。