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

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

2个例外:

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

我喜欢:

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版本必须以“诚实”的方式来实现。 我想我们可以看到为什么+现在更快了。

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

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

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

对于你的问题

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

Apache Commons-Lang有一个超级容易使用的ToStringBuilder类。它在处理附加逻辑以及格式化你想要的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 =, = foo)。

或者使用链接的更浓缩的形式:

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

或者如果你想使用反射来包含类的每个字段:

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

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

使用'+'的字符串连接的性能更昂贵，因为它必须创建一个全新的字符串副本，因为字符串在java中是不可变的。如果连接非常频繁，例如:在循环中，这将发挥特别的作用。 以下是我的想法，当我试图做这样的事情:

一般规则:

在单个字符串赋值中，使用字符串连接是很好的。 如果您正在循环构建一个大的字符数据块，请使用StringBuffer。 在String上使用+=总是比使用StringBuffer效率低，所以它应该敲响警钟——但在某些情况下，所获得的优化与可读性问题相比微不足道，所以使用你的常识。

这里有一篇关于这个话题的Jon Skeet博客。