談談JDK8中的字符串拼接

字符串拼接問題應該是每一個Java程序員都熟知的事情了，幾乎每一個Java程序員都讀過關於StringBuffer/StringBuilder來拼接字符串。

在大多數的教程中，也許你會看到用+號拼接字符串會生成多個String，致使性能過差，建議使用StringBuffer/StringBuilder來拼接。

但是真的是這樣的嗎？

本文在JDK8中作了以下實驗:

public static void main(String[] args) {
        String result = "";
        result += "some more data";
        System.out.println(result);
    }

經過javap -c來反編譯獲得：

Code:
       0: aload_0          // Push 'this' on to the stack
       1: invokespecial #1 // Invoke Object class constructor
                           // pop 'this' ref from the stack
       4: return           // Return from constructor

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2 // Load constant #2 on to the stack
       2: astore_1         // Create local var from stack (pop #2)
       3: new           #3 // Push new StringBuilder ref on stack
       6: dup              // Duplicate value on top of the stack
       7: invokespecial #4 // Invoke StringBuilder constructor
                           // pop object reference
      10: aload_1          // Push local variable containing #2
      11: invokevirtual #5 // Invoke method StringBuilder.append()
                           // pop obj reference + parameter
                           // push result (StringBuilder ref)
      14: ldc           #6 // Push "some more data" on the stack
      16: invokevirtual #5 // Invoke StringBuilder.append
                           // pop twice, push result
      19: invokevirtual #7 // Invoke StringBuilder.toString:();
      22: astore_1         // Create local var from stack (pop #6)
      23: getstatic     #8 // Push value System.out:PrintStream
      26: aload_1          // Push local variable containing #6
      27: invokevirtual #9 // Invoke method PrintStream.println()
                           // pop twice (object ref + parameter)
      30: return           // Return void from method

能夠看到Java編譯器優化了生成的字節碼，自動建立了一個StringBuilder，並進行append操做。

因爲構建最終字符串的子字符串在編譯時已經已知了，在這種狀況下Java編譯器纔會進行如上的優化。這種優化稱爲a static string concatenation optimization，自JDK5時就開始啓用。

那是否就能說明在JDK5之後，咱們再也不須要手動生成StringBuilder，經過+號也能達到一樣的性能？

咱們嘗試下動態拼接字符串：

動態拼接字符串指的是僅在運行時才知道最終字符串的子字符串。好比在循環中增長字符串：

public static void main(String[] args) {
        String result = "";
        for (int i = 0; i < 10; i++) {
            result += "some more data";
        }
        System.out.println(result);
    }

一樣反編譯：

Code:
       0: aload_0          // Push 'this' on to the stack
       1: invokespecial #1 // Invoke Object class constructor
                           // pop 'this' ref from the stack
       4: return           // Return from constructor

  public static void main(java.lang.String[]);
    Code:
       0: ldc            #2 // Load constant #2 on to the stack
       2: astore_1          // Create local var from stack, pop #2
       3: iconst_0          // Push value 0 onto the stack
       4: istore_2          // Pop value and store it in local var
       5: iload_2           // Push local var 2 on to the stack
       6: i2d               // Convert int to double on
                            // top of stack (pop + push)
       7: ldc2_w         #3 // Push constant 10e6 on to the stack
      10: dcmpg             // Compare two doubles on top of stack
                            // pop twice, push result: -1, 0 or 1
      11: ifge           40 // if value on top of stack is greater
                            // than or equal to 0 (pop once)
                            // branch to instruction at code 40
      14: new            #5 // Push new StringBuilder ref on stack
      17: dup               // Duplicate value on top of the stack
      18: invokespecial  #6 // Invoke StringBuilder constructor
                            // pop object reference
      21: aload_1           // Push local var 1 (empty String)
                            // on to the stack
      22: invokevirtual  #7 // Invoke StringBuilder.append
                            // pop obj ref + param, push result
      25: ldc            #8 // Push "some more data" on the stack
      27: invokevirtual  #7 // Invoke StringBuilder.append
                            // pop obj ref + param, push result
      30: invokevirtual  #9 // Invoke StringBuilder.toString
                            // pop object reference
      33: astore_1          // Create local var from stack (pop)
      34: iinc         2, 1 // Increment local variable 2 by 1
      37: goto            5 // Move to instruction at code 5
      40: getstatic     #10 // Push value System.out:PrintStream
      43: aload_1           // Push local var 1 (result String)
      44: invokevirtual #11 // Invoke method PrintStream.println()
                            // pop twice (object ref + parameter)
      47: return            // Return void from method

能夠看到在14的時候new了StringBuilder，可是在37的時候goto到了5，在循環過程當中，並無達到最優化，不斷在生成新的StringBuilder。

因此上述代碼相似：

String result = "";
for (int i = 0; i < 10; i++) {
    StringBuilder tmp = new StringBuilder();
    tmp.append(result);
    tmp.append("some more data");
    result = tmp.toString();
}
System.out.println(result);

能夠看到不斷生成新的StringBuilder，而且經過tostring，原來的StringBuilder將再也不引用，做爲垃圾，也增長了GC成本。

因此，在實際的使用中，當你沒法區分字符串是靜態拼接仍是動態拼接的時候，仍是使用StringBuilder吧。

Reference：
http://www.pellegrino.link/2015/08/22/string-concatenation-with-java-8.html

來源：開源中國---Hosee
連接：https://my.oschina.net/hosee/blog/1786130