+= 比 concat 更高效吗？

Question

我一直在阅读我团队中其他开发人员编写的代码，他们似乎更喜欢使用 += 进行字符串连接，而我更喜欢使用 .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);
    }
}

Answer 1

就可读性而言，我认为你是非常错误的。 + 胜过 .concat()。如果您使用的是 +=，您可能需要考虑 StringBuilder.append 为循环保留相同的 StringBuilder。

就性能而言，concat 优于 +。只要您只使用一个或两个即可。

对于concat，您最终将创建一个具有正确大小的char[]的String对象。这是你能得到的尽可能最佳的结果。

对于 + javac 生成的代码构造 StringBuilder 来执行附加操作，然后转换为 String。从 1.5 开始，您创建：

• StringBuilder （浪费）
• StringBuilder 的初始 char[] （浪费）
• 如果生成的序列太长，则使用第二个更大的序列char[]（浪费）
• 生成的String。
• String 的 char[]。

但是，您很少看到使用 concat，因为它更难以阅读。与其他正在发生的事情相比，几乎可以肯定，性能只是沧海一粟（提示：在优化之前先尝试一下信封背面）。

Answer 2

你应该做你认为最短、最清晰的事情。

不过，为了你的兴趣。

    String hello = "hello " + "world";

是最快的，因为编译将两个字符串合并为一个。

这对于两个字符串来说是最快的，因为它避免了创建 StringBuilder。

    String helloConcat = "hello ".concat(world);

但是，如果使用 StringBuilder 有两个以上的字符串，则隐式或显式的速度最快。

总之，我会使用 + 除非你将它放在循环中，在这种情况下我可能会显式使用 StringBuilder 来提高性能。

Answer 3

Concat对于两个字符串连接来说绝对是更快的选择，我不知道为什么javac内部使用

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

而不是

s1.concat(s2)

for s1 += s2。请参阅我对类似问题的回答连接运算符 (+) 与 concat()

Answer 4

我找到了这个 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 最快，+= 最慢。
仅供参考！

Answer 5

由于 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 与 StringBuffer 与 String.concat 的性能 - 做得正确

Answer 6

应该没关系。现代 Java 编译器、JVM 和 JIT 将以差异最小化的方式优化您的代码。您应该努力编写对您来说更具可读性和可维护性的代码。

Answer 7

我同意@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