连接运算符 (+) 与 concat() [重复]

Question

对于字符串连接，我们可以使用concat() 或连接运算符(+)。

我尝试了以下性能测试，发现concat() 是一种更快且内存高效的字符串连接方式。

100,000次的字符串连接比较：

String str = null;

//------------Using Concatenation operator-------------
long time1 = System.currentTimeMillis();
long freeMemory1 = Runtime.getRuntime().freeMemory();

for(int i=0; i<100000; i++){
    str = "Hi";
    str = str+" Bye";
}
long time2 = System.currentTimeMillis();
long freeMemory2 = Runtime.getRuntime().freeMemory();

long timetaken1 = time2-time1;
long memoryTaken1 = freeMemory1 - freeMemory2;
System.out.println("Concat operator  :" + "Time taken =" + timetaken1 +
                   " Memory Consumed =" + memoryTaken1);

//------------Using Concat method-------------
long time3 = System.currentTimeMillis();
long freeMemory3 = Runtime.getRuntime().freeMemory();
for(int j=0; j<100000; j++){
    str = "Hi";
    str = str.concat(" Bye");
}
long time4 = System.currentTimeMillis();
long freeMemory4 = Runtime.getRuntime().freeMemory();
long timetaken2 = time4-time3;
long memoryTaken2 = freeMemory3 - freeMemory4;
System.out.println("Concat method  :" + "Time taken =" + timetaken2 +
                   " Memory Consumed =" + memoryTaken2);

结果

Concat operator: Time taken = 31; Memory Consumed = 2259096
Concat method  : Time taken = 16; Memory Consumed = 299592

如果concat() 比运算符快，那么我们什么时候应该使用串联运算符(+)？

Answer 1

concat 方法总是产生一个带有连接结果的新字符串。

加号运算符由创建 StringBuilder 支持，附加您需要的所有 String 值并进一步调用它的 toString()。

因此，如果您需要连接两个值，concat() 将是更好的选择。如果需要连接 100 个值，则应使用加号运算符或显式使用 StringBuilder（例如，在循环中追加的情况下）。

Answer 2

其实两者都是一样的。如果你看到concat(String paramString)的代码，它会返回一个新的字符串对象，并且在（+）运算符中它还会生成一个新的字符串对象。

如果您不想创建新对象，请使用字符串生成器连接两个字符串。

Answer 3

一般来说，将字符串与+ 和concat() 连接是一种不好的做法。如果要创建字符串，请改用StringBuilder。

Answer 4

我相信连接的“风格”会有所作为。

对于 concat()，它在内部创建一个新的 char 数组缓冲区，并根据该 char 数组返回一个新字符串。

对于 + 运算符，编译器实际上将其转换为使用 StringBuffer/StringBuilder。

因此，如果要连接两个字符串，concat() 绝对是更好的选择，因为创建的对象数量只是结果字符串（以及内部使用的 char 缓冲区），而使用+ 运算符会被翻译到：

result = strA + strB;
-- translate to -->
result = new StringBuilder(strA).append(strB).toString();

创建了一个额外的 StringBuilder 实例。

但是，如果您要连接，例如连续五个字符串，每个 concat() 将创建一个新的 String 对象。在使用+ 运算符时，编译器会将语句转换为一个具有多个附加操作的 StringBuilder。这绝对是节省了很多不必要的临时对象实例：

result = strA + strB + strC + strD + strE;
-- translate to -->
result = new StringBuilder(strA).append(strB).append(strC).append(strD).append(strE).toString();

Answer 5

您可以始终使用 +，前提是您只使用 >= Java 1.5 并且您不在环形。在 Java 1.5 中，它会导致创建 new StringBuilder 并对其进行处理，直到您的字符串完成为止。这是最快的方法。

无论如何 - 如果你在一个循环中（并用+ 连接字符串） - 循环的每次迭代都会创建一个new StringBuilder - 这不是最好的主意。所以这是你应该强制使用StringBuilder 或StringBuffer（线程安全）类的地方。

通常，此链接清楚地回答了您的问题，并为您提供了完整的知识：

http://littletutorials.com/2008/07/16/stringbuffer-vs-stringbuilder-performance-comparison/

Answer 6

虽然操作符和方法都给出相同的输出，但它们内部的工作方式不同。

concat() 方法只连接 str1 和 str2 并输出一个字符串，对于少量连接更有效。

但使用连接运算符 '+', str1+=str2;将被解释为 str1 = new StringBuilder().append(str1).append(str2).toString();

当使用较少数量的字符串进行连接时，您可以使用 concat 方法。但是，如果您使用大量字符串，则 StringBuilder 方法在性能方面会很快。

Answer 7

您的测试需要运行至少 2 秒，每个循环以单独的方法运行才有意义。简短的测试可能很难重现和比较。从您的时间来看，您似乎正在使用 Windows（即，因为您的时间是 16 和 31 毫秒；）尝试 System.nanoTime() 代替。当您的循环迭代超过 10,000 次时，整个方法就会被编译。这意味着您后面的方法在启动时已经编译。

在回答您的问题时，添加两个字符串时 concat 会稍微快一些。但是，它带来了打字和概念上的开销，这可能比您节省的 CPU 大得多。即使基于您的测试重复 100,000 次，它也节省了不到 15 毫秒，但它所花费的时间远远超过您所花费的时间（这可能更值得）您可以在 JVM 的未来版本中找到，差异始终得到优化，代码的复杂性仍然存在。

---

编辑：我没有注意到内存结果是可疑的。

String str = null;

//------------Using Concatenation operator-------------
long time1 = System.currentTimeMillis();
long freeMemory1 = Runtime.getRuntime().freeMemory();
for (int i = 0; i < 10000; i++) {
    str = "Hi";
    str = str + " Bye";
}
long time2 = System.currentTimeMillis();
long freeMemory2 = Runtime.getRuntime().freeMemory();

long timetaken1 = time2 - time1;
long memoryTaken1 = freeMemory1 - freeMemory2;
System.out.println("Concat operator  :" + "Time taken =" + timetaken1 + " Memory Consumed= " + memoryTaken1);

str = null;
//------------Using Concat method-------------
long time3 = System.currentTimeMillis();
long freeMemory3 = Runtime.getRuntime().freeMemory();
for (int j = 0; j < 10000; j++) {
    str = "Hi";
    str = str.concat(" Bye");

}
long time4 = System.currentTimeMillis();
long freeMemory4 = Runtime.getRuntime().freeMemory();

long timetaken2 = time4 - time3;
long memoryTaken2 = freeMemory3 - freeMemory4;
System.out.println("Concat method  :" + "Time taken =" + timetaken2 + " Memory Consumed= " + memoryTaken2);

使用-XX:-UseTLAB -mx1g 运行时打印

Concat operator  :Time taken =12 Memory Consumed= 1291456
Concat method  :Time taken =7 Memory Consumed= 560000

使得内存使用比例约为2:1。在原始问题中，每次运行结果都会有所不同，有时.concat() 似乎使用更多。

Answer 8

其实s1 + s2和s1.concat(s2)是很不一样的。

s1 + s2被javac转换成

(new StringBuilder(String.valueOf(s1)).append(s2).toString();

反编译.class可以看到。这种结构不是很有效；它涉及最多三个new char[] 分配和三个char[] 复制操作。

s1.concat(s2) 永远是一个new char[] + 一个复制操作，见String.java

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    char buf[] = new char[count + otherLen];
    getChars(0, count, buf, 0);
    str.getChars(0, otherLen, buf, count);
    return new String(0, count + otherLen, buf);
}

注意new String(int, int, char[]) 是String 的包私有构造函数。它直接使用char buf[]，无需通常的复制，以确保String 不变性的buf 不可见性。