一. 性能方面

StringBuilder > StringBuffer > concat > +
測試代碼：

private static StringBuilder stringBuilder = new StringBuilder();

  private static StringBuffer stringBuffer = new StringBuffer();

  private static String string = "";

  private static String string2 = "";
  @Test
  public void testAdd() {
    long start = System.currentTimeMillis();
    String str = "";
    for (int i = 0; i < 400000; i++) {
      str = str + "a";
    }
    System.out.println("1:"+ (System.currentTimeMillis() - start));

    long start2 = System.currentTimeMillis();
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 400000; i++) {
      sb.append("a");
    }
    System.out.println("2:"+(System.currentTimeMillis() - start2));

    long start3 = System.currentTimeMillis();
    StringBuffer sb2 = new StringBuffer();
    for (int i = 0; i < 400000; i++) {
      sb2.append("a");
    }
    System.out.println("3:"+(System.currentTimeMillis() - start3));

    long start4 = System.currentTimeMillis();
    String str4 = "";
    for (int i = 0; i < 400000; i++) {
      str4 = str4.concat("a");
    }
    System.out.println("4:"+(System.currentTimeMillis() - start4));
  }

結果：

1:25787
2:6
3:6
4:17546

實現原理：

首先StringBuilder和StringBuffer的區別在于StringBuffer的所有public方法都加上了synchronized關鍵字，保證線程安全，而從根本實現層面來說，四者都是通過調用System.arraycopy()實現的：

1. StringBuilder：

public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }

private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }

public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
        if (srcBegin < 0) {
            throw new StringIndexOutOfBoundsException(srcBegin);
        }
        if (srcEnd > value.length) {
            throw new StringIndexOutOfBoundsException(srcEnd);
        }
        if (srcBegin > srcEnd) {
            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
        }
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }

可以看到，通常情況下，一次append()會調用兩次System.arraycopy()方法

2. oncat：

public String concat(String var1) {
    int var2 = var1.length();
    if (var2 == 0) {
      return this;
    } else {
      int var3 = this.value.length;
      char[] var4 = Arrays.copyOf(this.value, var3 + var2);
      var1.getChars(var4, var3);
      return new String(var4, true);
    }
  }

public static char[] copyOf(char[] original, int newLength) {
        char[] copy = new char[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

void getChars(char[] var1, int var2) {
    System.arraycopy(this.value, 0, var1, var2, this.value.length);
  }

可以看到，一次concat()也是調用了兩次System.arraycopy()方法，但是每次調用concat()方法都會調用一次new String()創建一個新的string對象，因此concat操作耗時較長

3. +

+運算符被重載，但是底層也是通過調用StringBuilder.append()實現的（jdk1.6 以上），而它之所以耗時是因為每次調用都會創建一個新的StringBuilder對象。

二 線程安全

測試代碼和結果

@Test
  public void threadSafeTest(){
    ExecutorService executor = Executors.newCachedThreadPool();
    for(int i = 0 ;i < 5000 ;i++){
      executor.execute( () -> {
        stringBuilder.append("a");
          }
      );
    }
    System.out.println("stringBuilder："+stringBuilder.length());

    long start2 = System.currentTimeMillis();
    for(int i = 0 ;i < 5000 ;i++){
      executor.execute( () -> {
            stringBuffer.append("a");
          }
      );
    }
    System.out.println("stringBuffer："+stringBuffer.length());

    for(int i = 0 ;i < 5000 ;i++){
      executor.execute( () -> {
            string = string.concat("a");
          }
      );
    }
    System.out.println("concat："+string.length());

    for(int i = 0 ;i < 5000 ;i++){
      executor.execute( () -> {
            string2 = string2 + "a";
          }
      );
    }
    System.out.println("+："+string2.length());
  }

stringBuilder：4987
stringBuffer：5000
concat：4139
+：3260

可以看到，只有StringBuffer是線程安全的，其他幾種拼接方式都不是線程安全的（如果length = 5000，那么代表是線程安全的）