不，不完全是。

首先，语义上略有不同。如果a为空，则a.c concat(b)抛出NullPointerException，但a+=b将把a的原始值视为空值。此外，concat()方法只接受String值，而+运算符将无声地将参数转换为String(对对象使用toString()方法)。因此concat()方法在接受内容方面更加严格。

为了深入了解，用a += b写一个简单的类;

public class Concat {
    String cat(String a, String b) {
        a += b;
        return a;
    }
}

现在使用javap -c(包含在Sun JDK中)进行反汇编。您应该看到一个清单，包括:

java.lang.String cat(java.lang.String, java.lang.String);
  Code:
   0:   new     #2; //class java/lang/StringBuilder
   3:   dup
   4:   invokespecial   #3; //Method java/lang/StringBuilder."<init>":()V
   7:   aload_1
   8:   invokevirtual   #4; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   11:  aload_2
   12:  invokevirtual   #4; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   15:  invokevirtual   #5; //Method java/lang/StringBuilder.toString:()Ljava/lang/    String;
   18:  astore_1
   19:  aload_1
   20:  areturn

a += b等于

a = new StringBuilder()
    .append(a)
    .append(b)
    .toString();

concat方法应该更快。但是，对于更多的字符串，StringBuilder方法胜出，至少在性能方面是这样。

String和StringBuilder的源代码(以及它的包私有基类)可以在Sun JDK的src.zip中找到。您可以看到您正在构建一个char数组(根据需要调整大小)，然后在创建最终String时将其丢弃。实际上，内存分配的速度快得惊人。

更新:正如Pawel Adamski所指出的，性能在最近的HotSpot中有所改变。Javac仍然生成完全相同的代码，但是字节码编译器会作弊。简单的测试完全失败，因为整个代码体都被丢弃了。总结系统。identityHashCode(不是String.hashCode)显示StringBuffer代码有一点优势。可能会在发布下一次更新时更改，或者如果您使用不同的JVM。来自@lukaseder的HotSpot JVM intrinsic列表。

+运算符可以在字符串、char、integer、double或float数据类型值之间工作。它只是在连接之前将值转换为字符串表示形式。

concat操作符只能在字符串上执行。它检查数据类型兼容性，如果不匹配，则抛出错误。

除此之外，您提供的代码也做同样的事情。

为了完整起见，我想补充一下，'+'操作符的定义可以在JLS SE8 15.18.1中找到:

如果只有一个操作数表达式为String类型，则String 在另一个操作数上执行转换(§5.1.11)以生成一个 字符串。 字符串连接的结果是对string对象的引用 这是两个操作数字符串的连接。的字符 在右操作数字符的前面 新创建的字符串中的操作数。 String对象是新创建的(§12.5)，除非表达式是 常量表达式(§15.28)

关于实现，JLS说了以下几点:

An implementation may choose to perform conversion and concatenation in one step to avoid creating and then discarding an intermediate String object. To increase the performance of repeated string concatenation, a Java compiler may use the StringBuffer class or a similar technique to reduce the number of intermediate String objects that are created by evaluation of an expression. For primitive types, an implementation may also optimize away the creation of a wrapper object by converting directly from a primitive type to a string.

因此，从“Java编译器可能使用StringBuffer类或类似的技术来减少”判断，不同的编译器可以产生不同的字节码。

这里的大多数答案都来自2008年。随着时间的推移，情况似乎发生了变化。我最近用JMH做的基准测试显示，在Java 8 +上比concat快两倍左右。

我的基准:

@Warmup(iterations = 5, time = 200, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 5, time = 200, timeUnit = TimeUnit.MILLISECONDS)
public class StringConcatenation {

    @org.openjdk.jmh.annotations.State(Scope.Thread)
    public static class State2 {
        public String a = "abc";
        public String b = "xyz";
    }

    @org.openjdk.jmh.annotations.State(Scope.Thread)
    public static class State3 {
        public String a = "abc";
        public String b = "xyz";
        public String c = "123";
    }


    @org.openjdk.jmh.annotations.State(Scope.Thread)
    public static class State4 {
        public String a = "abc";
        public String b = "xyz";
        public String c = "123";
        public String d = "!@#";
    }

    @Benchmark
    public void plus_2(State2 state, Blackhole blackhole) {
        blackhole.consume(state.a+state.b);
    }

    @Benchmark
    public void plus_3(State3 state, Blackhole blackhole) {
        blackhole.consume(state.a+state.b+state.c);
    }

    @Benchmark
    public void plus_4(State4 state, Blackhole blackhole) {
        blackhole.consume(state.a+state.b+state.c+state.d);
    }

    @Benchmark
    public void stringbuilder_2(State2 state, Blackhole blackhole) {
        blackhole.consume(new StringBuilder().append(state.a).append(state.b).toString());
    }

    @Benchmark
    public void stringbuilder_3(State3 state, Blackhole blackhole) {
        blackhole.consume(new StringBuilder().append(state.a).append(state.b).append(state.c).toString());
    }

    @Benchmark
    public void stringbuilder_4(State4 state, Blackhole blackhole) {
        blackhole.consume(new StringBuilder().append(state.a).append(state.b).append(state.c).append(state.d).toString());
    }

    @Benchmark
    public void concat_2(State2 state, Blackhole blackhole) {
        blackhole.consume(state.a.concat(state.b));
    }

    @Benchmark
    public void concat_3(State3 state, Blackhole blackhole) {
        blackhole.consume(state.a.concat(state.b.concat(state.c)));
    }


    @Benchmark
    public void concat_4(State4 state, Blackhole blackhole) {
        blackhole.consume(state.a.concat(state.b.concat(state.c.concat(state.d))));
    }
}

结果:

Benchmark                             Mode  Cnt         Score         Error  Units
StringConcatenation.concat_2         thrpt   50  24908871.258 ± 1011269.986  ops/s
StringConcatenation.concat_3         thrpt   50  14228193.918 ±  466892.616  ops/s
StringConcatenation.concat_4         thrpt   50   9845069.776 ±  350532.591  ops/s
StringConcatenation.plus_2           thrpt   50  38999662.292 ± 8107397.316  ops/s
StringConcatenation.plus_3           thrpt   50  34985722.222 ± 5442660.250  ops/s
StringConcatenation.plus_4           thrpt   50  31910376.337 ± 2861001.162  ops/s
StringConcatenation.stringbuilder_2  thrpt   50  40472888.230 ± 9011210.632  ops/s
StringConcatenation.stringbuilder_3  thrpt   50  33902151.616 ± 5449026.680  ops/s
StringConcatenation.stringbuilder_4  thrpt   50  29220479.267 ± 3435315.681  ops/s

基本上，+和concat方法之间有两个重要的区别。

If you are using the concat method then you would only be able to concatenate strings while in case of the + operator, you can also concatenate the string with any data type. For Example: String s = 10 + "Hello"; In this case, the output should be 10Hello. String s = "I"; String s1 = s.concat("am").concat("good").concat("boy"); System.out.println(s1); In the above case you have to provide two strings mandatory. The second and main difference between + and concat is that: Case 1: Suppose I concat the same strings with concat operator in this way String s="I"; String s1=s.concat("am").concat("good").concat("boy"); System.out.println(s1); In this case total number of objects created in the pool are 7 like this: I am good boy Iam Iamgood Iamgoodboy Case 2: Now I am going to concatinate the same strings via + operator String s="I"+"am"+"good"+"boy"; System.out.println(s); In the above case total number of objects created are only 5. Actually when we concatinate the strings via + operator then it maintains a StringBuffer class to perform the same task as follows:- StringBuffer sb = new StringBuffer("I"); sb.append("am"); sb.append("good"); sb.append("boy"); System.out.println(sb); In this way it will create only five objects.

伙计们，这就是+和concat方法的基本区别。 享受:)

我不这么想。

a.concat(b)是在String中实现的，我认为自早期java机器以来，实现没有太大变化。+操作的实现取决于Java版本和编译器。目前+是使用StringBuffer实现的，以使操作尽可能快。也许在未来，这种情况会改变。在java +的早期版本中，对字符串的操作要慢得多，因为它产生中间结果。

我猜+=是使用+实现的，并进行了类似的优化。