string相加的各類狀況分析

爲了加深理解，咱們能夠來作幾個小實驗。

javac Test         編譯文件
javap -c Test   查看虛擬機指令

實驗一：純字符串

Java code?

1 2 3 4 5

public class Test {     public static void main(String args[]) {         String str = "a";     } }

   // 將字符串 a 存入常數池
   0:   ldc     #2; //String a
   // 將引用存放到 1 號局部變量中
   2:   astore_1
   3:   return

實驗二：純字符串相加

Java code?

1 2 3 4 5

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

   // 將字符串 ab 壓入常數池
   0:   ldc     #2; //String ab
   2:   astore_1
   3:   return

實驗二能夠很明顯地看出，編譯器在編譯時產生的字節碼已經將 "a" + "b" 優化成了 "ab"，
同理多個字符串的相加也會被優化處理，須要注意的是字符串常量相加。

實驗三：字符串與自動提高常量相加

Java code?

1 2 3 4 5

public class Test {     public static void main(String args[]) {         String str = "a" + (1 + 2);     } }

   // 將字符串 a3 壓入常數池
   0:   ldc     #2; //String a3
   2:   astore_1
   3:   return

經過虛擬機指令能夠看出，1 + 2 自動提高後的常量與字符串常量，虛擬機也會對其進行優化。

實驗2、實驗三結論：常量間的相加並不會引發效率問題

實驗四：字符串與變量相加

Java code?

1 2 3 4 5 6

public class Test {     public static void main(String args[]) {         String s = "b";         String str = "a" + s;     } }

   // 將字符串 b 壓入常數池
   0:   ldc     #2; //String b
   // 將引用存放到 1 號局部變量中
   2:   astore_1
   // 檢查到很是量的相加，這時建立 StringBuilder 對象
   3:   new     #3; //class java/lang/StringBuilder
   // 從棧中複製出數據，即把字符串 b 複製出來
   6:   dup
   // 調用 StringBuilder 的初始構造
   7:   invokespecial   #4; //Method java/lang/StringBuilder."<init>":()V
   // 將字符串 a 壓入常數池
   10:  ldc     #5; //String a
   // 調用 StringBuilder 的 append 方法，把字符串 a 添加進去
   12:  invokevirtual   #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   // 從 1 號局部變量中加載數據引用
   15:  aload_1
   // 調用 StringBuilder 的 append 方法，把字符串 b 添加進去
   16:  invokevirtual   #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   // 調用 StringBuilder 的 toString 方法
   19:  invokevirtual   #7; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   // 將 toString 的結果保存至 2 號局部變量
   22:  astore_2
   23:  return

實驗四能夠看出，很是量字會串相加時，因爲相加的變量中存放的是字符串的地址引用，
由於在編譯時沒法確切地知道其餘具體的值，也就沒有辦法對其進行優化處理，這時爲了
達到鏈接的效果，其內部採用了 StringBuilder 的機制進行處理（JDK 5 中新增的，我
這裏沒有 JDK 1.4，估計在 JDK 1.4 下采用的是 StringBuffer），將他們都 append
進去，最後用 toString 輸出。

若 s 爲其餘類型時，好比：int 類型，也是採用同種方式進行處理。

同理，根據實驗二的結果，在 String str = "a" + "b" + s; 時，先會優化成 "ab" 再與
s 根據實驗四的方式進行處理，這時 StringBuilder 僅調用了兩次 append 方法。

若是是 String str = "a" + s + "b"; 這種形式的就沒辦法優化了，StringBuilder 得調
用三次 append 方法。

實驗四的結論代表，字符串與變量相加時在內部產生了 StringBuilder 對象並採起了必定
的操做。

若是隻有一句 String str = "a" + s; 這樣子的，其效率與
String str = new StringBuilder().append("a").append(s).toString();
是同樣的。

通常所說的 String 採用鏈接運算符（+）效率低下主要產生在如下的狀況中：
 

Java code?

1 2 3 4 5 6 7 8

public class Test {     public static void main(String args[]) {         String s = null;         for(int i = 0; i < 100; i++) {             s += "a";         }     } }

每作一次 + 就產生個 StringBuilder 對象，而後 append 後就扔掉。下次循環再到達時重 新產生個 StringBuilder 對象，而後 append 字符串，如此循環直至結束。 若是咱們直接採用 StringBuilder 對象進行 append 的話，咱們能夠節省 N - 1 次建立和 銷燬對象的時間。