StringBuilder 与 Java 中 toString() 中的字符串连接

https://stackoverflow.com/questions/1532461

20-09-2019
|

题

鉴于 2 toString() 下面的实现，哪一个是首选：

public String toString(){
    return "{a:"+ a + ", b:" + b + ", c: " + c +"}";
}

或者

public String toString(){
    StringBuilder sb = new StringBuilder(100);
    return sb.append("{a:").append(a)
          .append(", b:").append(b)
          .append(", c:").append(c)
          .append("}")
          .toString();
}

更重要的是，考虑到我们只有 3 个属性，这可能没有什么区别，但你会在什么时候从 + 连接到 StringBuilder?

解决方案

版本 1 更可取，因为它更短并且编译器实际上会将其转换为版本 2 - 没有任何性能差异。

更重要的是，鉴于我们只有3个属性，这可能不会有所作为，但是在什么时候您可以从Concat转到建造者？

当你在循环中连接时 - 通常是编译器无法替换的时候 StringBuilder 通过它自己。

其他提示

关键在于您是在一个地方编写单个串联还是随着时间的推移累积它。

对于您给出的示例，显式使用 StringBuilder 是没有意义的。（查看第一个案例的编译代码。）

但是如果你正在构建一个字符串，例如在循环内，使用 StringBuilder。

为了澄清，假设巨大数组包含数千个字符串，代码如下：

...
String result = "";
for (String s : hugeArray) {
    result = result + s;
}

与以下相比，非常浪费时间和内存：

...
StringBuilder sb = new StringBuilder();
for (String s : hugeArray) {
    sb.append(s);
}
String result = sb.toString();

我更喜欢：

String.format( "{a: %s, b: %s, c: %s}", a, b, c );

...因为它简短且可读。

我会不是优化它以提高速度，除非您在重复次数非常高的循环中使用它和测量了性能差异。

我同意，如果您必须输出很多参数，这种形式可能会变得混乱（就像其中一条评论所说的那样）。在这种情况下，我会切换到更具可读性的形式（也许使用字符串生成器 apache-commons - 取自 matt b) 的答案并再次忽略性能。

在大多数情况下，您不会看到两种方法之间的实际差异，但很容易构建像这样的最坏情况场景：

public class Main
{
    public static void main(String[] args)
    {
        long now = System.currentTimeMillis();
        slow();
        System.out.println("slow elapsed " + (System.currentTimeMillis() - now) + " ms");

        now = System.currentTimeMillis();
        fast();
        System.out.println("fast elapsed " + (System.currentTimeMillis() - now) + " ms");
    }

    private static void fast()
    {
        StringBuilder s = new StringBuilder();
        for(int i=0;i<100000;i++)
            s.append("*");      
    }

    private static void slow()
    {
        String s = "";
        for(int i=0;i<100000;i++)
            s+="*";
    }
}

输出是：

slow elapsed 11741 ms
fast elapsed 7 ms

问题是 += 附加到字符串会重建一个新字符串，因此它的成本与字符串的长度（两者的总和）呈线性关系。

所以 - 对于你的问题：

第二种方法会更快，但可读性较差且难以维护。正如我所说，在您的具体情况下，您可能看不到差异。

我还与我的老板在使用追加还是+的问题上发生了冲突。因为他们正在使用追加（我仍然无法弄清楚他们每次创建新对象时都会说的话）。所以我想做一些研发。虽然我喜欢迈克尔·博格沃特的解释，但只是想展示一个解释，如果有人将来真的需要知道的话。

/**
 *
 * @author Perilbrain
 */
public class Appc {
    public Appc() {
        String x = "no name";
        x += "I have Added a name" + "We May need few more names" + Appc.this;
        x.concat(x);
        // x+=x.toString(); --It creates new StringBuilder object before concatenation so avoid if possible
        //System.out.println(x);
    }

    public void Sb() {
        StringBuilder sbb = new StringBuilder("no name");
        sbb.append("I have Added a name");
        sbb.append("We May need few more names");
        sbb.append(Appc.this);
        sbb.append(sbb.toString());
        // System.out.println(sbb.toString());
    }
}

上述类的反汇编结果为

 .method public <init>()V //public Appc()
  .limit stack 2
  .limit locals 2
met001_begin:                                  ; DATA XREF: met001_slot000i
  .line 12
    aload_0 ; met001_slot000
    invokespecial java/lang/Object.<init>()V
  .line 13
    ldc "no name"
    astore_1 ; met001_slot001
  .line 14

met001_7:                                      ; DATA XREF: met001_slot001i
    new java/lang/StringBuilder //1st object of SB
    dup
    invokespecial java/lang/StringBuilder.<init>()V
    aload_1 ; met001_slot001
    invokevirtual java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lan\
g/StringBuilder;
    ldc "I have Added a nameWe May need few more names"
    invokevirtual java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lan\
g/StringBuilder;
    aload_0 ; met001_slot000
    invokevirtual java/lang/StringBuilder.append(Ljava/lang/Object;)Ljava/lan\
g/StringBuilder;
    invokevirtual java/lang/StringBuilder.toString()Ljava/lang/String;
    astore_1 ; met001_slot001
  .line 15
    aload_1 ; met001_slot001
    aload_1 ; met001_slot001
    invokevirtual java/lang/String.concat(Ljava/lang/String;)Ljava/lang/Strin\
g;
    pop
  .line 18
    return //no more SB created
met001_end:                                    ; DATA XREF: met001_slot000i ...

; ===========================================================================

;met001_slot000                                ; DATA XREF: <init>r ...
    .var 0 is this LAppc; from met001_begin to met001_end
;met001_slot001                                ; DATA XREF: <init>+6w ...
    .var 1 is x Ljava/lang/String; from met001_7 to met001_end
  .end method
;44-1=44
; ---------------------------------------------------------------------------


; Segment type: Pure code
  .method public Sb()V //public void Sb
  .limit stack 3
  .limit locals 2
met002_begin:                                  ; DATA XREF: met002_slot000i
  .line 21
    new java/lang/StringBuilder
    dup
    ldc "no name"
    invokespecial java/lang/StringBuilder.<init>(Ljava/lang/String;)V
    astore_1 ; met002_slot001
  .line 22

met002_10:                                     ; DATA XREF: met002_slot001i
    aload_1 ; met002_slot001
    ldc "I have Added a name"
    invokevirtual java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lan\
g/StringBuilder;
    pop
  .line 23
    aload_1 ; met002_slot001
    ldc "We May need few more names"
    invokevirtual java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lan\
g/StringBuilder;
    pop
  .line 24
    aload_1 ; met002_slot001
    aload_0 ; met002_slot000
    invokevirtual java/lang/StringBuilder.append(Ljava/lang/Object;)Ljava/lan\
g/StringBuilder;
    pop
  .line 25
    aload_1 ; met002_slot001
    aload_1 ; met002_slot001
    invokevirtual java/lang/StringBuilder.toString()Ljava/lang/String;
    invokevirtual java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lan\
g/StringBuilder;
    pop
  .line 28
    return
met002_end:                                    ; DATA XREF: met002_slot000i ...


;met002_slot000                                ; DATA XREF: Sb+25r
    .var 0 is this LAppc; from met002_begin to met002_end
;met002_slot001                                ; DATA XREF: Sb+9w ...
    .var 1 is sbb Ljava/lang/StringBuilder; from met002_10 to met002_end
  .end method
;96-49=48
; ---------------------------------------------------------------------------

从上面两段代码可以看出Michael是对的。每种情况下只创建一个SB对象。

从 Java 1.5 开始，使用“+”和 StringBuilder.append() 进行简单的一行连接会生成完全相同的字节码。

所以为了代码的可读性，使用“+”。

2 个例外：

多线程环境：字符串缓冲区
循环中的串联：字符串生成器/字符串缓冲区

使用最新版本的Java(1.8)反汇编(javap -c）显示编译器引入的优化。 + 还有 sb.append() 将生成非常相似的代码。然而，如果我们使用的话，检查行为是值得的 + 在 for 循环中。

在 for 循环中使用 + 添加字符串

爪哇：

public String myCatPlus(String[] vals) {
    String result = "";
    for (String val : vals) {
        result = result + val;
    }
    return result;
}

字节码:(for 循环摘录）

12: iload         5
14: iload         4
16: if_icmpge     51
19: aload_3
20: iload         5
22: aaload
23: astore        6
25: new           #3                  // class java/lang/StringBuilder
28: dup
29: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
32: aload_2
33: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
36: aload         6
38: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
41: invokevirtual #6                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
44: astore_2
45: iinc          5, 1
48: goto          12

使用 stringbuilder.append 添加字符串

爪哇：

public String myCatSb(String[] vals) {
    StringBuilder sb = new StringBuilder();
    for(String val : vals) {
        sb.append(val);
    }
    return sb.toString();
}

字节Cdoe:(for 循环摘录）

17: iload         5
19: iload         4
21: if_icmpge     43
24: aload_3
25: iload         5
27: aaload
28: astore        6
30: aload_2
31: aload         6
33: invokevirtual #5                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
36: pop
37: iinc          5, 1
40: goto          17
43: aload_2

有一点 明显的差异 尽管。在第一种情况下，其中 + 被用过，新的 StringBuilder 为每个 for 循环迭代创建，并通过执行以下操作来存储生成的结果 toString() 致电（29 至 41）。因此，您正在生成使用时真正不需要的中间字符串 + 运算符在 for 环形。

在 Java 9 中，版本 1 应该更快，因为它被转换为 invokedynamic 称呼。更多详细信息可以参见 JEP-280:

这个想法是用对 java.lang.invoke.StringConcatFactory 的简单 invokedynamic 调用来替换整个 StringBuilder 附加舞蹈，它将接受需要连接的值。

Apache Commons-Lang 有一个字符串生成器超级容易使用的类。它在处理追加逻辑以及格式化您希望 toString 的外观方面做得很好。

public void toString() {
     ToStringBuilder tsb =  new ToStringBuilder(this);
     tsb.append("a", a);
     tsb.append("b", b)
     return tsb.toString();
}

将返回如下输出 com.blah.YourClass@abc1321f[a=whatever, b=foo].

或者使用链接以更简洁的形式：

public void toString() {
     return new ToStringBuilder(this).append("a", a).append("b", b").toString();
}

或者，如果您想使用反射来包含类的每个字段：

public String toString() {
    return ToStringBuilder.reflectionToString(this);
}

如果需要，您还可以自定义 ToString 的样式。

出于性能原因，使用 += (String 串联）是不鼓励的。原因是：爪哇 String 是不可变的，每次进行新的串联时都会产生新的 String 已创建（新指纹已与旧指纹不同）在字符串池中）。创建新字符串会给 GC 带来压力并减慢程序速度：对象的创建是昂贵的。

下面的代码应该让它更加实用和清晰。

public static void main(String[] args) 
{
    // warming up
    for(int i = 0; i < 100; i++)
        RandomStringUtils.randomAlphanumeric(1024);
    final StringBuilder appender = new StringBuilder();
    for(int i = 0; i < 100; i++)
        appender.append(RandomStringUtils.randomAlphanumeric(i));

    // testing
    for(int i = 1; i <= 10000; i*=10)
        test(i);
}

public static void test(final int howMany) 
{
    List<String> samples = new ArrayList<>(howMany);
    for(int i = 0; i < howMany; i++)
        samples.add(RandomStringUtils.randomAlphabetic(128));

    final StringBuilder builder = new StringBuilder();
    long start = System.nanoTime();
    for(String sample: samples)
        builder.append(sample);
    builder.toString();
    long elapsed = System.nanoTime() - start;
    System.out.printf("builder - %d - elapsed: %dus\n", howMany, elapsed / 1000);

    String accumulator = "";
    start = System.nanoTime();
    for(String sample: samples)
        accumulator += sample;
    elapsed = System.nanoTime() - start;
    System.out.printf("concatenation - %d - elapsed: %dus\n", howMany, elapsed / (int) 1e3);

    start = System.nanoTime();
    String newOne = null;
    for(String sample: samples)
        newOne = new String(sample);
    elapsed = System.nanoTime() - start;
    System.out.printf("creation - %d - elapsed: %dus\n\n", howMany, elapsed / 1000);
}

运行结果报告如下。

builder - 1 - elapsed: 132us
concatenation - 1 - elapsed: 4us
creation - 1 - elapsed: 5us

builder - 10 - elapsed: 9us
concatenation - 10 - elapsed: 26us
creation - 10 - elapsed: 5us

builder - 100 - elapsed: 77us
concatenation - 100 - elapsed: 1669us
creation - 100 - elapsed: 43us

builder - 1000 - elapsed: 511us
concatenation - 1000 - elapsed: 111504us
creation - 1000 - elapsed: 282us

builder - 10000 - elapsed: 3364us 
concatenation - 10000 - elapsed: 5709793us
creation - 10000 - elapsed: 972us

不考虑 1 个串联的结果（JIT 尚未完成其工作），即使对于 10 个串联，性能损失也是相关的；对于数千个串联，差异是巨大的。

从这个非常快速的实验中吸取的教训（可以使用上面的代码轻松重现）：切勿使用 += 将字符串连接在一起，即使是在需要一些连接的非常基本的情况下（如上所述，创建新字符串无论如何都是昂贵的，并且会给 GC 带来压力）。

使 toString 方法尽可能具有可读性！

在我的书中，唯一的例外是如果你可以证明对我来说，它消耗大量资源:)（是的，这意味着分析）

另请注意，Java 5 编译器生成的代码比 Java 早期版本中使用的手写“StringBuffer”方法更快。如果您使用“+”，则此功能和未来的增强功能都是免费的。

当前编译器是否仍需要使用 StringBuilder 似乎存在一些争论。所以我想我会给出我2美分的经验。

我有一个 JDBC 10k 记录的结果集（是的，我需要一批中的所有记录。）在我的机器上使用 + 运算符大约需要 5 分钟 Java 1.8. 。使用 stringBuilder.append("") 对于同一查询，只需不到一秒的时间。

所以差别是很大的。在循环内 StringBuilder 速度要快得多。

请参阅下面的示例：

//java8
static void main(String[] args) {
    case1();//str.concat
    case2();//+=
    case3();//StringBuilder
}

static void case1() {
    List<Long> savedTimes = new ArrayList();
    long startTimeAll = System.currentTimeMillis();
    String str = "";
    for (int i = 0; i < MAX_ITERATIONS; i++) {
        long startTime = System.currentTimeMillis();
        str = str.concat(UUID.randomUUID()+"---");
        saveTime(savedTimes, startTime);
    }
    System.out.println("Created string of length:"+str.length()+" in "+(System.currentTimeMillis()-startTimeAll)+" ms");
}

static void case2() {
    List<Long> savedTimes = new ArrayList();
    long startTimeAll = System.currentTimeMillis();
    String str = "";
    for (int i = 0; i < MAX_ITERATIONS; i++) {
        long startTime = System.currentTimeMillis();
        str+=UUID.randomUUID()+"---";
        saveTime(savedTimes, startTime);
    }        
    System.out.println("Created string of length:"+str.length()+" in "+(System.currentTimeMillis()-startTimeAll)+" ms");
}

static void case3() {
    List<Long> savedTimes = new ArrayList();
    long startTimeAll = System.currentTimeMillis();
    StringBuilder str = new StringBuilder("");
    for (int i = 0; i < MAX_ITERATIONS; i++) {
        long startTime = System.currentTimeMillis();
        str.append(UUID.randomUUID()+"---");
        saveTime(savedTimes, startTime);
    }        
    System.out.println("Created string of length:"+str.length()+" in "+(System.currentTimeMillis()-startTimeAll)+" ms");

}

static void saveTime(List<Long> executionTimes, long startTime) {
        executionTimes.add(System.currentTimeMillis()-startTime);
        if(executionTimes.size()%CALC_AVG_EVERY == 0) {
            out.println("average time for "+executionTimes.size()+" concatenations: "+
                    NumberFormat.getInstance().format(executionTimes.stream().mapToLong(Long::longValue).average().orElseGet(()->0))+
                    " ms avg");
            executionTimes.clear();
        }
}

输出：

10000 次串联的平均时间：平均 0.096 毫秒
10000 次串联的平均时间：平均 0.185 毫秒
10000 次串联的平均时间：平均 0.327 毫秒
10000 次串联的平均时间：平均 0.501 毫秒
10000 次串联的平均时间：平均 0.656 毫秒
创建长度为 1950000 的字符串 17745 毫秒
10000 次串联的平均时间：平均 0.21 毫秒
10000 次串联的平均时间：平均 0.652 毫秒
10000 次串联的平均时间：平均 1.129 毫秒
10000 次串联的平均时间：平均 1.727 毫秒
10000 次串联的平均时间：平均 2.302 毫秒
创建长度为 1950000 的字符串 60279 毫秒
10000 次串联的平均时间：平均 0.002 毫秒
10000 次串联的平均时间：平均 0.002 毫秒
10000 次串联的平均时间：平均 0.002 毫秒
10000 次串联的平均时间：平均 0.002 毫秒
10000 次串联的平均时间：平均 0.002 毫秒
创建长度为 1950000 的字符串 100毫秒

随着字符串长度的增加，连接时间也会增加。
那就是 StringBuilder 绝对需要。
如您所见，串联： UUID.randomUUID()+"---", ，并没有真正影响时间。

附：我不认为何时在 Java 中使用 StringBuilder 确实是这个的重复。
这个问题谈到 toString() 大多数时候不执行大字符串的串联。

在性能方面，使用“+”进行字符串连接的成本更高，因为它必须创建一个全新的字符串副本，因为字符串在 java 中是不可变的。如果串联非常频繁，这会发挥特别的作用，例如：在一个循环内。以下是当我尝试做这样的事情时我的想法建议：

一般规则：

在单个字符串赋值中，使用字符串连接就可以了。
如果您要循环构建大量字符数据，请选择 StringBuffer。
在 String 上使用 += 总是比使用 StringBuffer 效率低，因此应该敲响警钟 - 但在某些情况下，与可读性问题相比，获得的优化可以忽略不计，因此请使用常识。

这里有一个不错的乔恩·斯基特博客围绕这个话题。

我可以指出，如果您要迭代集合并使用 StringBuilder，您可能需要查看阿帕奇通用语言和 StringUtils.join() （不同口味）？

无论性能如何，它都会让您不必创建 StringBuilder 和 for 循环，以实现看起来像 百万分之一 时间。

我比较了四种不同的方法来比较性能。我完全不知道 gc 会发生什么，但对我来说重要的是时间。编译器是这里很重要的因素。我在window8.1平台下使用jdk1.8.0_45。

concatWithPlusOperator = 8
concatWithBuilder = 130
concatWithConcat = 127
concatStringFormat = 3737
concatWithBuilder2 = 46

public class StringConcatenationBenchmark {

private static final int MAX_LOOP_COUNT = 1000000;

public static void main(String[] args) {

    int loopCount = 0;
    long t1 = System.currentTimeMillis();
    while (loopCount < MAX_LOOP_COUNT) {
        concatWithPlusOperator();
        loopCount++;
    }
    long t2 = System.currentTimeMillis();
    System.out.println("concatWithPlusOperator = " + (t2 - t1));

    long t3 = System.currentTimeMillis();
    loopCount = 0;
    while (loopCount < MAX_LOOP_COUNT) {
        concatWithBuilder();
        loopCount++;
    }
    long t4 = System.currentTimeMillis();
    System.out.println("concatWithBuilder = " + (t4 - t3));

    long t5 = System.currentTimeMillis();
    loopCount = 0;
    while (loopCount < MAX_LOOP_COUNT) {
        concatWithConcat();
        loopCount++;
    }
    long t6 = System.currentTimeMillis();
    System.out.println("concatWithConcat = " + (t6 - t5));

    long t7 = System.currentTimeMillis();
    loopCount = 0;
    while (loopCount < MAX_LOOP_COUNT) {
        concatStringFormat();
        loopCount++;
    }
    long t8 = System.currentTimeMillis();
    System.out.println("concatStringFormat = " + (t8 - t7));

    long t9 = System.currentTimeMillis();
    loopCount = 0;
    while (loopCount < MAX_LOOP_COUNT) {
        concatWithBuilder2();
        loopCount++;
    }
    long t10 = System.currentTimeMillis();
    System.out.println("concatWithBuilder2 = " + (t10 - t9));
}

private static void concatStringFormat() {
    String s = String.format("%s %s %s %s ", "String", "String", "String", "String");
}

private static void concatWithConcat() {
    String s = "String".concat("String").concat("String").concat("String");
}

private static void concatWithBuilder() {
    StringBuilder builder=new StringBuilder("String");
    builder.append("String").append("String").append("String");
    String s = builder.toString();
}

private static void concatWithBuilder2() {
    String s = new StringBuilder("String").append("String").append("String").append("String").toString();
}

private static void concatWithPlusOperator() {
    String s = "String" + "String" + "String" + "String";
}
}

这是我在Java8中检查的内容

使用字符串连接

使用字符串生成器

long time1 = System.currentTimeMillis();
usingStringConcatenation(100000);
System.out.println("usingStringConcatenation " + (System.currentTimeMillis() - time1) + " ms");

time1 = System.currentTimeMillis();
usingStringBuilder(100000);
System.out.println("usingStringBuilder " + (System.currentTimeMillis() - time1) + " ms");


private static void usingStringBuilder(int n)
{
    StringBuilder str = new StringBuilder();
    for(int i=0;i<n;i++)
        str.append("myBigString");    
}

private static void usingStringConcatenation(int n)
{
    String str = "";
    for(int i=0;i<n;i++)
        str+="myBigString";
}

如果您对大量字符串使用字符串连接，那真是一场噩梦。

usingStringConcatenation 29321 ms
usingStringBuilder 2 ms

我认为我们应该采用 StringBuilder 附加方法。原因是

String 连接每次都会创建一个新的字符串对象（由于 String 是不可变对象），因此会创建 3 个对象。
使用字符串生成器，只会创建一个对象[StringBuilder 是可变的]，并且将进一步的字符串附加到它。

对于像这样的简单字符串，我更喜欢使用

"string".concat("string").concat("string");

按照顺序，我想说构造字符串的首选方法是使用 StringBuilder、String#concat()，然后是重载的 + 运算符。当处理大型字符串时，StringBuilder 会显着提高性能，就像使用 + 运算符会导致性能大幅下降（随着字符串大小的增加，性能呈指数级大幅下降）。使用 .concat() 的一个问题是它可能会抛出 NullPointerExceptions。

许可以下： CC-BY-SA 和归因

不隶属于 StackOverflow