Java 中的 String、StringBuffer、StringBuilder

《阿里巴巴 Java 开发手册》中有一条是关于字符串拼接的建议：

123

上面说使用 + 拼接会造成资源浪费，就是消耗内存，我们就简单模拟一下。

开干

使用 for 循环分别对String、StringBuffer、StringBuilder进行 10000 次字符串拼接，并统计耗时。

使用 String 拼接：

static void StringTest() {
    String str = "";
    long begin = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        str += i;
    }
    long end = System.currentTimeMillis();
    long result = end- begin;
    System.out.println("String 拼接耗时：" + result);
}

使用 StringBuffer 拼接：

static void StringBufferTest() {
    StringBuffer str = new StringBuffer();
    long begin = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        str.append(i);
    }
    long end = System.currentTimeMillis();
    long result = end- begin;
    System.out.println("StringBuffer 拼接耗时：" + result);
}

使用 StringBilder 拼接：

static void StringBuilderTest() {
    StringBuilder str = new StringBuilder();
    long begin = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        str.append(i);
    }
    long end = System.currentTimeMillis();
    long result = end- begin;
    System.out.println("StringBuilder 拼接耗时：" + result);
}

结果

上面的代码，同一电脑执行结果是（单位为：Millis）：

String 拼接耗时：23051
StringBuffer 拼接耗时：4
StringBuilder 拼接耗时：3

结果表明，三者的执行效率是： StringBuilder > StringBuffer > String。其中 String 的耗时居然是 StringBuffer 和 StringBuilder 的几千倍。

接下来找下他们的效率快慢的原因。

分析

关于 String

String 是不可扩展的字符串变量

String 的工作方式

以下举个例子：

String str = "ABCD";
str += "加点东西";

我们都知道 String 是不可扩展的字符串变量(内存地址不会变，创建了之后，该常量就不会改变了)，当编译器执行 String str = "ABCD"; 的时候，内存的方法区中会分配一个空间给常量 "ABCD", 栈中的变量 str 指向常量 "ABCD" 的内存地址，这时候完成 String str = "ABCD"; 这行代码。

这时候如果我们对 str 进行拼接操作，即执行 str += "加点东西"; , 那么编译器首先会在方法区的常量池寻找有没有 "ABCD加点东西" 这个字符串常量(这时候肯定是没有该常量)。那么编译器会在常量池中重新开辟一块空间给 "ABCD加点东西" (但是其实这个步骤，在底层实现的时候也是每次循环都会 StringBuilder对象，并调用其中的 append 方法进行拼接, 这也印证了为什么会 String 比 StringBuilder 效率低)，栈中的 str 变量指向 "ABCD加点东西" 的内存地址，完成一次拼接。

这样做就十分费内存，也就是浪费资源。

关于 StringBuffer 和 StringBuilder

StringBuffer 和 StringBuilder 都是可扩展的字符串类型。

StringBuffer 和 StringBuilder 工作方式

举个例子：

StringBuilder sb = new StringBuilder("ABCD");
sb.append("加点东西");
// 或者以下
StringBuffer sb = new StringBuffer("ABCD");
sb.append("加点东西");

StringBuffer 和 StringBuilder 的内部数组 默认长度 = 初始化字符串长度 + 16。所以当 new StringBuilder("ABCD"); 执行完 new 之后，实际上在 sb 中的 capacity() 的返回值是 20。这时候会在堆区创建一个 StringBuffer 或者 StringBuilder 对象，同时会到方法去的产量池中寻找是否有 "ABCD" 这个常量，然后 StringBuffer 或者 StringBuilder 对象指向常量池的 "ABCD" 这个常量。

当执行 sb.append("加点东西"); 这行代码的时候，编译器就会去常量池找是否有 "ABCD加点东西" 常量，如果没有那么就看 StringBuffer 或者 StringBuilder 对象 的长度能都装载下 "加点东西" 该字符串（如果不够那么就增加到当前长度的 150%）。此时的内存地址是不变的。

所以相对 String 的每次拼接都要在内存中重新分配一块内存空间，StringBuffer 或者 StringBuilder 的效率自然而言要给 String 的拼接速度要快。

StringBuffer 和 StringBuilder 区别

既然说 StringBuffer 和 StringBuilder 效率差不多，那么为啥还要两个？其中有什么区别呢？

StringBuffer 比 StringBuilder 的实现方法前多了一个 synchronized，也就是同步锁，这样会使 StringBuffer 在并发编程中更加安全，可靠。StringBuilder 在日常开发中是最常见，也是效率最高的。

小结

拼接效率：

StringBuilder > StringBuffer > String

推荐使用 StringBuilder。

Java 中的 String、StringBuffer、StringBuilder 效率