Java核心类——StringBuilder

小结

StringBuilder是可变对象，用来高效拼接字符串；
StringBuilder可以支持链式操作，实现链式操作的关键是返回实例本身；
StringBuffer是StringBuilder的线程安全版本，现在很少使用。
用指定分隔符拼接字符串数组时，使用StringJoiner或者String.join()更方便；
用StringJoiner拼接字符串时，还可以额外附加一个“开头”和“结尾”。

StringBuilder&StringBuffer

Java编译器对String做了特殊处理，使得我们可以

直接用+拼接字符串

。

考察下面的循环代码：

String s = "";
for (int i = 0; i < 1000; i++) {
    s = s + "," + i;
}

虽然可以直接拼接字符串，但是，在循环中，每次循环都会创建新的字符串对象，然后扔掉旧的字符串。这样，绝大部分字符串都是临时对象，不但浪费内存，还会影响GC效率。

为了能高效拼接字符串，Java标准库提供了
StringBuilder
，它是一个可变对象，可以预分配缓冲区，这样，往StringBuilder中新增字符时，不会创建新的临时对象：

StringBuilder sb = new StringBuilder(1024);
for (int i = 0; i < 1000; i++) {
    sb.append(',');
    sb.append(i);
}
String s = sb.toString();

StringBuilder
还可以进行链式操作：

// 链式操作
public class Main {
    public static void main(String[] args) {
        var sb = new StringBuilder(1024);
        sb.append("Mr ")
          .append("Bob")
          .append("!")
          .insert(0, "Hello, ");
        System.out.println(sb.toString());
    }
}

如果我们查看
StringBuilder的源码
，可以发现，进行链式操作的关键是，

定义的append()方法会返回this

，这样，就可以不断调用自身的其他方法。

仿照StringBuilder，我们也可以设计支持链式操作的类。例如，一个可以不断增加的计数器：

// 链式操作
public class Main {
    public static void main(String[] args) {
        Adder adder = new Adder();
        adder.add(3)
             .add(5)
             .inc()
             .add(10);
        System.out.println(adder.value());
    }
}

class Adder {
    private int sum = 0;

    public Adder add(int n) {
        sum += n;
        return this;
    }

    public Adder inc() {
        sum ++;
        return this;
    }

    public int value() {
        return sum;
    }
}

注意

：对于普通的
字符串+操作
，并不需要我们将其改写为
StringBuilder
，因为Java编译器在编译时就自动把多个连续的+操作编码为
StringConcatFactory
的操作。在运行期，
StringConcatFactory
会自动把字符串连接操作优化为数组复制或者
StringBuilder
操作。

你可能还听说过
StringBuffer
，这是Java早期的一个
StringBuilder
的线程安全版本，它通过同步来保证多个线程操作
StringBuffer
也是安全的，但是同步会带来执行速度的下降。

StringBuilder
和
StringBuffer
接口完全相同，现在完全没有必要使用
StringBuffer
。

要高效拼接字符串，应该使用StringBuilder。

StringJoiner

很多时候，我们拼接的字符串像这样：

// Hello Bob, Alice, Grace!
public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        var sb = new StringBuilder();
        sb.append("Hello ");
        for (String name : names) {
            sb.append(name).append(", ");
        }
        // 注意去掉最后的", ":
        sb.delete(sb.length() - 2, sb.length());
        sb.append("!");
        System.out.println(sb.toString());
    }
}

Hello Bob, Alice, Grace!

类似用分隔符拼接数组的需求很常见，所以Java标准库还提供了一个
StringJoiner
来干这个事：

import java.util.StringJoiner;
public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        var sj = new StringJoiner(", ");
        for (String name : names) {
            sj.add(name);
        }
        System.out.println(sj.toString());
    }
}

Bob, Alice, Grace

慢着！用
StringJoiner
的结果少了前面的
"Hello "
和结尾的
"!"
！遇到这种情况，需要给
StringJoiner
指定“开头”和“结尾”：

import java.util.StringJoiner;
public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        var sj = new StringJoiner(", ", "Hello ", "!");
        for (String name : names) {
            sj.add(name);
        }
        System.out.println(sj.toString());
    }
}

Hello Bob, Alice, Grace!

String.join()

String还提供了一个静态方法join()，这个方法在内部使用了StringJoiner来拼接字符串，在不需要指定“开头”和“结尾”的时候，用String.join()更方便：

String[] names = {"Bob", "Alice", "Grace"};
var s = String.join(", ", names);

目录

小结

StringBuilder&StringBuffer

StringJoiner

String.join()

你可能也喜欢