我一直在阅读团队中其他开发人员编写的代码，他们似乎更喜欢使用+= 进行字符串连接，而我更喜欢使用.concat()，因为它更易于阅读。
我试图准备一个论据，说明为什么使用.concat() 更好，我想知道，两者之间的效率有什么区别吗？
我们“应该”采取哪个选项？
public class Stuff {
public static void main(String[] args) {
String hello = "hello ";
hello += "world";
System.out.println(hello);
String helloConcat = "hello ".concat("world");
System.out.println(helloConcat);
}
}
【问题讨论】：
标签： java string string-concatenation
由于 String 在 java 中是不可变的，所以当您执行 +、+= 或 concat(String) 时，会生成一个新的 String。字符串越大，所需的时间就越长——要复制的内容越多，产生的垃圾就越多。
今天的 java 编译器优化了你的字符串连接，使其达到最优，例如
System.out.println("x:"+x+" y:"+y);
编译器将其生成为：
System.out.println((new StringBuilder()).append("x:").append(x).append(" y:").append(y).toString());
我的建议是编写更易于维护和阅读的代码。
此链接显示StringBuilder vs StringBuffer vs String.concat - done right的性能
【讨论】：
应该没关系。现代 Java 编译器、JVM 和 JIT 将优化您的代码，使差异可能最小化。您应该努力编写对您来说更具可读性和可维护性的代码。
【讨论】：
我同意@darioo 和大多数其他答案。始终将可读性（和可维护性）放在首位。 （现代的 JIT 编译器应该不会遇到像这样的简单情况的问题。）
然而，这是与您的程序相对应的字节码。 （请注意，+= 方法会产生 StringBuilder，这通常是构造字符串时的首选方法。）
// String hello = "hello";
0: ldc #2; //String hello
2: astore_1
// hello += "world";
3: new #3; //class java/lang/StringBuilder
6: dup
7: invokespecial #4; //Method StringBuilder."<init>"
10: aload_1
11: invokevirtual #5; //Method StringBuilder.append
14: ldc #6; //String world
16: invokevirtual #5; //Method StringBuilder.append
19: invokevirtual #7; //Method StringBuilder.toString
// System.out.println(hello);
22: astore_1
23: getstatic #8; //Field System.out
26: aload_1
27: invokevirtual #9; //Method PrintStream.println
// String helloConcat = "hello ".concat("world");
30: ldc #2; //String hello
32: ldc #6; //String world
34: invokevirtual #10; //Method String.concat
37: astore_2
// System.out.println(helloConcat);
38: getstatic #8; //Field System.out
41: aload_2
42: invokevirtual #9; //Method PrintStream.println
45: return
【讨论】：
就可读性而言，我认为你是非常错误的。 + 战胜 .concat()。如果您使用的是+=，您可能需要考虑将StringBuilder.append 保持与循环相同的StringBuilder。
在性能方面concat 优于+。只要你只使用一个或两个。
在concat 的情况下，您最终将创建一个具有正确大小的char[] 的String 对象。它几乎是您可以获得的最佳效果。
对于+，javac 生成构造StringBuilder 的代码来执行附加，然后转换为String。从您创建的 1.5 开始：
StringBuilder（废物）StringBuilder 的初始 char[]（浪费）char[]（浪费）String。String 的char[]。但是，您很少看到使用concat，因为它更难阅读。与其他情况相比，性能几乎肯定是沧海一粟（提示：在优化之前先试试信封的背面）。
【讨论】：
你应该做你认为对你来说最短和最清楚的事情。
但是，为了您的利益。
String hello = "hello " + "world";
编译将两个String合二为一是最快的。
这对于两个字符串来说是最快的，因为它避免了创建 StringBuilder。
String helloConcat = "hello ".concat(world);
但是，如果您有两个以上的字符串使用 StringBuilder，则隐式或显式最快。
总的来说，我会使用 + ，除非你在循环中使用它，在这种情况下，我可能会显式使用 StringBuilder 来提高性能。
【讨论】：
StringBuilder 并且没有区别。
concat绝对是两个字符串连接的更快选择，不知道javac内部为什么使用
(new StringBuilder(String.valueOf(s1))).append(s2).toString()
而不是
s1.concat(s2)
对于 s1 += s2。查看我对类似问题的回答concatenation operator (+) vs concat()
【讨论】：
我找到了这个artical 并做了这个测试：
public static void main(String[] args) {
String s1 = generateString();
String s2 = generateString();
String s3 = generateString();
String s4 = generateString();
String s5 = generateString();
String s6 = generateString();
long e = System.currentTimeMillis();
for(int i=0;i<10000000;i++){
//StringBuilder > concat> plus >StringBuffer >plusEqual(">"means faster than)
//concatPlus(s1 , s2 , s3 , s4 , s5 , s6);//4204ms
//concatBuilder(s1 , s2 , s3 , s4 , s5 , s6);//2562ms
//concatBuffer(s1 , s2 , s3 , s4 , s5 , s6);//4610ms
//concatPlusEqual(s1 , s2 , s3 , s4 , s5 , s6);//9843ms
//concatConcat(s1 , s2 , s3 , s4 , s5 , s6);//3036ms
}
System.out.println(System.currentTimeMillis()-e);
}
public static String concatPlusEqual(String s1, String s2, String s3, String s4,
String s5, String s6) {
String result = "";
result += s1;
result += s2;
result += s3;
result += s4;
result += s5;
result += s6;
return result;
}
public static String concatConcat(String s1, String s2, String s3, String s4,
String s5, String s6) {
String result = new String();
result.concat(s1);
result.concat(s2);
result.concat(s3);
result.concat(s4);
result.concat(s5);
result.concat(s6);
return result;
}
public static String concatBuffer(String s1, String s2, String s3, String s4,
String s5, String s6) {
return new StringBuffer(s1.length() + s2.length() + s3.length()
+ s4.length() + s5.length() + s6.length()).append(s1)
.append(s2).append(s3).append(s4).append(s5).append(s6)
.toString();
}
public static String concatBuilder(String s1, String s2, String s3, String s4,
String s5, String s6) {
return new StringBuilder(s1.length() + s2.length() + s3.length()
+ s4.length() + s5.length() + s6.length()).append(s1)
.append(s2).append(s3).append(s4).append(s5).append(s6)
.toString();
}
public static String concatPlus(String s1,String s2,String s3,String s4,String s5,String s6) {
return s1 + s2 + s3 + s4 + s5 + s6;
}
public static String generateString()
{
Random rng = new Random();
int length = 10;
String characters ="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char[] text = new char[length];
for (int i = 0; i < length; i++)
{
text[i] = characters.charAt(rng.nextInt(characters.length()));
}
return new String(text);
}
看起来 StringBuilder 最快，而 += 最慢。
仅供参考！
【讨论】：