给定下面的2个toString()实现，哪个是首选的:
public String toString(){
return "{a:"+ a + ", b:" + b + ", c: " + c +"}";
}
or
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个属性，它可能不会有什么不同，但在什么时候你会从+ concat切换到StringBuilder?
当前回答
使用最新版本的Java(1.8)的反汇编(javap -c)显示了编译器引入的优化。+以及sb.append()将生成非常相似的代码。然而，如果我们在for循环中使用+，检查行为将是值得的。
在for循环中使用+添加字符串
Java:
public String myCatPlus(String[] vals) {
String result = "";
for (String val : vals) {
result = result + val;
}
return result;
}
ByteCode:(用于循环摘录)
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添加字符串
Java:
public String myCatSb(String[] vals) {
StringBuilder sb = new StringBuilder();
for(String val : vals) {
sb.append(val);
}
return sb.toString();
}
ByteCdoe:(循环摘录)
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
不过，两者还是有一些明显的区别。在第一种情况下，使用了+，为每次for循环迭代创建新的StringBuilder，并通过执行toString()调用存储生成的结果(29到41)。所以当你在for循环中使用+运算符时，你会生成你真正不需要的中间字符串。
其他回答
使用'+'的字符串连接的性能更昂贵，因为它必须创建一个全新的字符串副本，因为字符串在java中是不可变的。如果连接非常频繁，例如:在循环中，这将发挥特别的作用。 以下是我的想法，当我试图做这样的事情:
一般规则:
在单个字符串赋值中，使用字符串连接是很好的。 如果您正在循环构建一个大的字符数据块，请使用StringBuffer。 在String上使用+=总是比使用StringBuffer效率低，所以它应该敲响警钟——但在某些情况下，所获得的优化与可读性问题相比微不足道，所以使用你的常识。
这里有一篇关于这个话题的Jon Skeet博客。
版本1更可取，因为它更短，而且编译器实际上会把它转换成版本2——没有任何性能差异。
更重要的是，我们只有3个 属性，它可能不会生成 不同，但在什么情况下 从concat转到builder?
当你在一个循环中连接时——那通常是编译器不能自己替换StringBuilder的时候。
在Java 9中，版本1应该更快，因为它被转换为invokedynamic调用。更多细节可以在JEP-280中找到:
其思想是用对java.lang.invoke的简单invokedynamic调用替换整个StringBuilder追加舞蹈。StringConcatFactory，它将接受需要连接的值。
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的样式。
关键在于你是在一个地方写一个连接，还是在一段时间内把它积累起来。
对于您给出的示例，显式使用StringBuilder是没有意义的。(请查看第一个案例的编译代码。)
但是如果你正在构建一个字符串，例如在一个循环中，使用StringBuilder。
为了澄清，假设hugeArray包含数千个字符串，代码如下:
...
String result = "";
for (String s : hugeArray) {
result = result + s;
}
与以下相比非常浪费时间和内存:
...
StringBuilder sb = new StringBuilder();
for (String s : hugeArray) {
sb.append(s);
}
String result = sb.toString();
