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

因此，为了代码的可读性，请使用“+”。

2个例外:

多线程环境:StringBuffer 循环中的连接:StringBuilder/StringBuffer

出于性能考虑，不鼓励使用+=(字符串连接)。原因是:Java String是一个不可变的，每当一个新的连接完成时，一个新的String就会被创建(新的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带来压力)。

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

因此，为了代码的可读性，请使用“+”。

2个例外:

多线程环境:StringBuffer 循环中的连接:StringBuilder/StringBuffer

在大多数情况下，你不会看到这两种方法之间的实际区别，但很容易构建一个像下面这样的最坏情况:

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

问题是，+=追加到一个字符串重构一个新的字符串，所以它的代价是字符串长度的线性(两者的和)。

对于你的问题

第二种方法更快，但可读性较差，也更难维护。 正如我所说，在你的具体情况下，你可能看不到区别。

我喜欢:

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

.．.因为它简短易读。

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

我同意，如果必须输出大量参数，这个表单可能会令人困惑(就像其中一个评论所说的那样)。在这种情况下，我将切换到更可读的形式(可能使用apache-commons的ToStringBuilder -取自matt b的答案)，并再次忽略性能。

值得一提的是，正如@ZhekaKozlov指出的那样，

自Java 9以来，+更快，除非JVM不知道如何优化它(例如，循环中的连接)。

我检查了以下代码的字节码(在Java 17中):

public class StringBM {
    public String toStringPlus(String a) {
        return "{a:" + a + ", b:" + ", c: " + "}";
    }

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

For toStringPlus:

 0: aload_1
 1: invokedynamic #7,  0              // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;)Ljava/lang/String;
 6: areturn

for toStringBuilder:

 0: new           #11                 // class java/lang/StringBuilder
 3: dup
 4: bipush        100
 6: invokespecial #13                 // Method java/lang/StringBuilder."<init>":(I)V
 9: astore_2
10: aload_2
11: ldc           #16                 // String {a:
13: invokevirtual #18                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
16: aload_1
17: invokevirtual #18                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
20: ldc           #22                 // String , b:
22: invokevirtual #18                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
25: ldc           #24                 // String , c:
27: invokevirtual #18                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
30: ldc           #26                 // String }
32: invokevirtual #18                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
35: invokevirtual #28                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
38: areturn

+版本简单地调用动态函数makeConcatWithConstants和并传入方法参数{a:\u0001, b:， c:} (\u0001是参数占位符)。 而StringBuilder版本必须以“诚实”的方式来实现。 我想我们可以看到为什么+现在更快了。