String操作符 “+” 原理

String相加底层是如何实现的

public class StringOperator {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String ab = a+b;    
    }
}

代码如上，很简单，使用javap -c 反编译看下。

本文使用的是JDK 1.8

Compiled from "StringOperator.java"
public class StringOperator {
  public StringOperator();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String a
       2: astore_1
       3: ldc           #3                  // String b
       5: astore_2
       6: new           #4                  // class java/lang/StringBuilder
       9: dup
      10: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
      13: aload_1
      14: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      17: aload_2
      18: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      21: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      24: astore_3
      25: return
}

6 ：创建一个StringBuilder对象

14：调用对象方法append()

18：再次调用对象方法append()

21：调用对象方法toString()

上面代码相加操作其实就相当于：String ab = new StringBuilder().append(“a”).append(“b”).toString();

也就是说 “+” 底层是由StringBuilder去实现。

一个简单的验证方法：直接在StringBuilder类的append()方法打断点进行验证。

然后顺路来扒一扒StringBuilder，我们知道它是一个线程不安全但是更为高效的字符串处理构建类。而StringBuffer正好相反，线程安全但低效。

源码结构上比较简单，StringBuilder和StringBuffer两者都是继成自AbstractStringBuilder，几乎所有的逻辑操作的都是都是在AbstractStringBuilder实现的。

AbstractStringBuilder内部也就是两个变量，注释也相当明了。因为对字符串的操作本身就是对变量value的操作，这样的话多个线程操作时会导致混乱。

/**
 * A mutable sequence of characters.
 */
abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     */
    char[] value;

    /**
     * The count is the number of characters used.
     */
    int count;

}

StringBuilder和StringBuffer基本上都是都是调用AbstractStringBuilder的方法，为何一个能线程安全另一个不能？原因很简单：StringBuffer的重写方法时都用了synchronized修饰，这就是它线程安全的原因。

另一个需要注意的是：

所有返回String类型的操作（如toString()、substring()）是根据value和count重新new一个等值的String并返回，这也就是说每次调用返回的String都是一个新的对象。如下：

StringBuilder sb = new StringBuilder();
sb.append("A");
System.out.println(sb.toString()==sb.toString());//输出结果：false

根据上面的分析，我们看下这段代码

String s = "";
for (int i=0;i<10000;i++){
    s = s + "abc";
}

那么它实际上是等价于下面这个代码的：

String s = "";
for (int i=0;i<10000;i++){
    s = new StringBuilder().append(s).append("abc").toString();
}

也就是说，这个循环内创建了10000个StringBuilder和10000个String！性能差距上不言而喻！所以我们应该直接使用StringBuilder，如下：

StringBuilder sb = new StringBuilder("");
for (int i=0;i<10000;i++){
    sb.append("abc");
}
String s = sb.toString();