有關(guān)String的源碼分析，可以查看一下我的前一篇文章：String源碼分析
要理解String的拼接過程，先要理解以下幾個(gè)概念
1.不可變的String
我們總是說String對象是不可變的，那到底是什么導(dǎo)致不可變？
首先談一談Java的機(jī)制，String在編譯階段會(huì)把已知的字面量放在常量池中，詳細(xì)可以參考Java-常量池
在String源碼分析里可以看到，String實(shí)質(zhì)是一個(gè)char數(shù)組，初始化字符串有兩種方式：
String a = "java";
String b = new String("java");
當(dāng)使用＝賦值的時(shí)候，相當(dāng)于把String的變量指java常量池中的"java";
而使用new賦值的時(shí)候則會(huì)在java堆中重新分配空間存放"java"。
無論是以上哪種方式生成的字符串，在生成結(jié)束后都是一個(gè)已知長度的char數(shù)組。大家都知道，數(shù)組的長度是不可改變的。
當(dāng)String變量重新賦值的時(shí)候，實(shí)則是將變量指向java常量池的另一個(gè)制，又或者是在java堆中重新分配空間存放。
而String類中每一個(gè)看起來會(huì)修改String值的方法，實(shí)際上都是創(chuàng)建了一個(gè)全新的String對象，則新的char數(shù)組，以包含修改后的字符串內(nèi)容。
因此說，String是不可變的。
2.重載“+”
在Java中，唯一被重載的運(yùn)算符就是用于String的“+”與“+=”。除此之外，Java不允許程序員重載其他的運(yùn)算符。
public class StringTest {
String a = "abc";
String b = "mongo";
String info = a + b + 47;
}
String對象是不可變的，所以在上述的代碼過程中可能會(huì)是這樣工作的：
1. "abc" + "mongo" 創(chuàng)建新的String對象abcmongo;
2. "abcmongo" + "47" 創(chuàng)建新的String對象abcmongo47;
3. 引用info 指向最終生成的String。
但是這種方式會(huì)生成一大堆需要垃圾回收的中間對象，性能相當(dāng)糟糕。
編譯器的優(yōu)化處理
Compiled from "StringTest.java"
public class StringTest {
java.lang.String a;
java.lang.String b;
java.lang.String info;
public StringTest();
Code:
0: aload_0
1: invokespecial #12 // Method java/lang/Object."<init>":
()V
4: aload_0
5: ldc #14 // String abc
7: putfield #16 // Field a:Ljava/lang/String;
10: aload_0
11: ldc #18 // String mongo
13: putfield #20 // Field b:Ljava/lang/String;
16: aload_0
17: new #22 // class java/lang/StringBuilder
20: dup
21: aload_0
22: getfield #16 // Field a:Ljava/lang/String;
25: invokestatic #24 // Method java/lang/String.valueOf:(
Ljava/lang/Object;)Ljava/lang/String;
28: invokespecial #30 // Method java/lang/StringBuilder."<
init>":(Ljava/lang/String;)V
31: aload_0
32: getfield #20 // Field b:Ljava/lang/String;
35: invokevirtual #33 // Method java/lang/StringBuilder.ap
pend:(Ljava/lang/String;)Ljava/lang/StringBuilder;
38: bipush 47
40: invokevirtual #37 // Method java/lang/StringBuilder.ap
pend:(I)Ljava/lang/StringBuilder;
43: invokevirtual #40 // Method java/lang/StringBuilder.to
String:()Ljava/lang/String;
46: putfield #44 // Field info:Ljava/lang/String;
49: return
}
反編譯以上代碼會(huì)發(fā)現(xiàn)，編譯器自動(dòng)引入了StringBuilder類。
編譯器創(chuàng)建了一個(gè)StringBuilder對象，并調(diào)用StringBuilder.append()方法，最后調(diào)用toString()生成結(jié)果，從而避免中間對象的性能損耗。
編譯器優(yōu)化String對象的連接，而下面這種情況會(huì)直接連接作為常量。
public class StringTest {
String info = "Andy" + "24" + "Developer";
}
Compiled from "StringTest.java"
public class StringTest {
java.lang.String info;
public StringTest();
Code:
0: aload_0
1: invokespecial #10 // Method java/lang/Object."<init>":
()V
4: aload_0
5: ldc #12 // String abcmongo47
7: putfield #14 // Field info:Ljava/lang/String;
10: return
}
3.編譯器的優(yōu)化是有限度的
- 性能較低的代碼
public void implicitUseStringBuilder(String[] values) {
String result = "";
for (int i = 0 ; i < values.length; i ++) {
result += values[i];
}
System.out.println(result);
}
public void implicitUseStringBuilder(java.lang.String[]);
Code:
0: ldc #11 // String
2: astore_2
3: iconst_0
4: istore_3
5: iload_3
6: aload_1
7: arraylength
8: if_icmpge 38
11: new #5 // class java/lang/StringBuilder
14: dup
15: invokespecial #6 // Method java/lang/StringBuilder."<init>":()V
18: aload_2
19: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
22: aload_1
23: iload_3
24: aaload
25: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28: invokevirtual #8 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
31: astore_2
32: iinc 3, 1
35: goto 5
38: getstatic #9 // Field java/lang/System.out:Ljava/io/PrintStream;
41: aload_2
42: invokevirtual #10 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
45: return
其中8: if_icmpge 38 和 35: goto 5構(gòu)成了一個(gè)循環(huán)。
8: if_icmpge 38的意思是如果（i < values.length的相反結(jié)果）成立，則跳到第38行（System.out）。
35: goto 5則表示直接跳到第5行。
但是這里面有一個(gè)很重要的就是StringBuilder對象創(chuàng)建發(fā)生在循環(huán)之間，也就是意味著有多少次循環(huán)會(huì)創(chuàng)建多少個(gè)StringBuilder對象，這樣明顯性能較低。
- 性能較高的代碼
public void explicitUseStringBuider(String[] values) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < values.length; i ++) {
result.append(values[i]);
}
}
public void explicitUseStringBuider(java.lang.String[]);
Code:
0: new #5 // class java/lang/StringBuilder
3: dup
4: invokespecial #6 // Method java/lang/StringBuilder."<init>":()V
7: astore_2
8: iconst_0
9: istore_3
10: iload_3
11: aload_1
12: arraylength
13: if_icmpge 30
16: aload_2
17: aload_1
18: iload_3
19: aaload
20: invokevirtual #7 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
23: pop
24: iinc 3, 1
27: goto 10
30: return
從上面可以看出，13: if_icmpge 30和27: goto 10構(gòu)成了一個(gè)loop循環(huán)，而0: new #5位于循環(huán)之外，所以不會(huì)多次創(chuàng)建StringBuilder.
綜上，循環(huán)體中需要盡量避免隱式或者顯式創(chuàng)建StringBuilder。
不過有種特殊情況，當(dāng)final修飾的變量發(fā)生連接動(dòng)作時(shí)，虛擬機(jī)會(huì)進(jìn)行優(yōu)化，將表達(dá)式結(jié)果直接賦值給目標(biāo)變量：
public class StringTest {
public static void main(String[] args) {
final String a = "hello ";
final String b = "world";
String c = a + b;
String d = "hello world";
}
}
編譯后字節(jié)碼如下：
4.StringBuilder
連接符號 "+" 本質(zhì)
在上文討論后得知，字符串變量（非final修飾）通過 "+" 進(jìn)行拼接，在編譯過程中會(huì)轉(zhuǎn)化為StringBuilder對象的append操作，注意是編譯過程，而不是在JVM中。
性能問題
StringBuilder內(nèi)部維護(hù)了一個(gè)char[]類型的value，用來保存通過append方法添加的內(nèi)容，通過 new StringBuilder()初始化時(shí)，char[]的默認(rèn)長度為16，如果append第17個(gè)字符，會(huì)發(fā)生什么？
void expandCapacity(int minimumCapacity) {
int newCapacity = value.length * 2 + 2;
if (newCapacity - minimumCapacity < 0)
newCapacity = minimumCapacity;
if (newCapacity < 0) {
if (minimumCapacity < 0) // overflow
throw new OutOfMemoryError();
newCapacity = Integer.MAX_VALUE;
}
value = Arrays.copyOf(value, newCapacity);
}
如果value的剩余容量，無法添加全部內(nèi)容，則通過expandCapacity(int minimumCapacity)方法對value進(jìn)行擴(kuò)容，其中minimumCapacity = 原value長度 + append添加的內(nèi)容長度。
