快捷導(dǎo)航

關(guān)于JDK8中的字符串拼接示例詳解

更新時間：2018年04月05日 08:32:54 作者：Hosee

字符串拼接問題應(yīng)該是每個Java程序員都熟知的事情了，幾乎每個Java程序員都讀過關(guān)于StringBuffer/StringBuilder來拼接字符串。下面這篇文章主要給大家介紹了關(guān)于JDK8中的字符串拼接的相關(guān)資料，需要的朋友可以參考下。

前言

在Java開發(fā)者中，字符串的拼接占用資源高往往是熱議的話題.

讓我們深入討論一下為什么會占用高資源。

在Java中，字符串對象是不可變的，意思是它一旦創(chuàng)建，你就無法再改變它。所以在我們拼接字符串的時候，創(chuàng)建了一個新的字符串，舊的被垃圾回收器所標(biāo)記。

如果我們處理上百萬的字符串，然后，我們就會生成百萬的額外字符串被垃圾回收器處理。

在大多數(shù)的教程中，也許你會看到用+號拼接字符串會生成多個String，導(dǎo)致性能過差，建議使用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編譯器優(yōu)化了生成的字節(jié)碼，自動創(chuàng)建了一個StringBuilder，并進(jìn)行append操作。

由于構(gòu)建最終字符串的子字符串在編譯時已經(jīng)已知了，在這種情況下Java編譯器才會進(jìn)行如上的優(yōu)化。這種優(yōu)化稱為a static string concatenation optimization，自JDK5時就開始啟用。

那是否就能說明在JDK5以后，我們不再需要手動生成StringBuilder，通過+號也能達(dá)到同樣的性能？

我們嘗試下動態(tài)拼接字符串：

動態(tài)拼接字符串指的是僅在運行時才知道最終字符串的子字符串。比如在循環(huán)中增加字符串：

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，在循環(huán)過程中，并沒有達(dá)到最優(yōu)化，不斷在生成新的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成本。

所以，在實際的使用中，當(dāng)你無法區(qū)分字符串是靜態(tài)拼接還是動態(tài)拼接的時候，還是使用StringBuilder吧。

Reference：

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

總結(jié)

以上就是這篇文章的全部內(nèi)容了，希望本文的內(nèi)容對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，如果有疑問大家可以留言交流，謝謝大家對腳本之家的支持。

您可能感興趣的文章: