簡書 占小狼
轉載請注明原創出處，謝謝！
連接符號 "+" 本質
在 淺談Java String內幕（1） 中，字符串變量（非final修飾）通過 "+" 進行拼接，在編譯過程中會轉化為StringBuilder對象的append操作，注意是編譯過程，而不是在JVM中。
public class StringTest {
public static void main(String[] args) {
String str1 = "hello ";
String str2 = "java";
String str3 = str1 + str2 + "!";
String str4 = new StringBuilder().append(str1).append(str2).append("!").toString();
}
}
上述 str3 和 str4 的執行效果其實是一樣的，不過在for循環中，千萬不要使用 "+" 進行字符串拼接。
public class test {
public static void main(String[] args) {
run1();
run2();
}
public static void run1() {
long start = System.currentTimeMillis();
String result = "";
for (int i = 0; i < 10000; i++) {
result += i;
}
System.out.println(System.currentTimeMillis() - start);
}
public static void run2() {
long start = System.currentTimeMillis();
StringBuilder builder = new StringBuilder();
for (int i = 0; i < 10000; i++) {
builder.append(i);
}
System.out.println(System.currentTimeMillis() - start);
}
}
在for循環中使用 "+" 和StringBuilder進行1萬次字符串拼接，耗時情況如下：
1、使用 "+" 拼接，平均耗時 250ms；
2、使用StringBuilder拼接，平均耗時 1ms；
for循環中使用 "+" 拼接為什么這么慢？下面是run1方法的字節碼指令
5 ~ 34 行對應for循環的代碼，可以發現，每次循環都會重新初始化StringBuilder對象，導致性能問題的出現。
性能問題
StringBuilder內部維護了一個char[]類型的value，用來保存通過append方法添加的內容，通過 new StringBuilder() 初始化時，char[]的默認長度為16，如果append第17個字符，會發生什么？
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的剩余容量，無法添加全部內容，則通過expandCapacity(int minimumCapacity)方法對value進行擴容，其中minimumCapacity = 原value長度 + append添加的內容長度。
1、擴大容量為原來的兩倍 + 2，為什么要 + 2，而不是剛好兩倍？
2、如果擴容之后，還是無法添加全部內容，則將 minimumCapacity 作為最終的容量大小；
3、利用 System.arraycopy 方法對原value數據進行復制；
在使用StringBuilder時，如果給定一個合適的初始值，可以避免由于char[]數組多次復制而導致的性能問題。
不同初始容量的性能測試：
public class StringBuilderTest {
public static void main(String[] args) {
int sum = 0;
final int capacity = 40000000;
for (int i = 0; i < 100; i++) {
sum += cost(capacity);
}
System.out.println(sum / 100);
}
public static long cost(int capacity) {
long start = System.currentTimeMillis();
StringBuilder builder = new StringBuilder(capacity);
for (int i = 0; i < 10000000; i++) {
builder.append("java");
}
return System.currentTimeMillis() - start;
}
}
執行一千萬次append操作，不同初始容量的耗時情況如下：
1、容量為默認16時，平均耗時110ms；
2、容量為40000000時，不會發生復制操作，平均耗時85ms；
通過以上數據可以發現，性能損耗不是很嚴重。
內存問題
1、StringBuilder內部進行擴容時，會新建一個大小為原來兩倍+2的char數組，并復制原char數組到新數組，導致內存的消耗，增加GC的壓力。
2、StringBuilder的toString方法，也會造成char數組的浪費。
public String toString() {
// Create a copy, don't share the array
return new String(value, 0, count);
}
String的構造方法中，會新建一個大小相等的char數組，并使用 System.arraycopy() 復制StringBuilder中char數組的數據，這樣StringBuilder的char數組就白白浪費了。
重用StringBuilder
public class StringBuilderHolder {
private final StringBuilder sb;
public StringBuilderHolder(int capacity) {
sb = new StringBuilder(capacity);
}
public StringBuilder resetAndGet() {
sb.setLength(0);
return sb;
}
}
通過 sb.setLength(0) 方法可以把char數組的內存區域設置為0，這樣char數組重復使用，為了避免并發訪問，可以在ThreadLocal中使用StringBuilderHolder，使用方式如下：
private static final ThreadLocal<StringBuilderHolder> stringBuilder= new ThreadLocal<StringBuilderHolder>() {
@Override
protected StringBuilderHolder initialValue() {
return new StringBuilderHolder(256);
}
};
StringBuilder sb = stringBuilder.get().resetAndGet();
不過這種方式也存在一個問題，該StringBuilder實例的內存空間一直不會被GC回收，如果char數組在某次操作中被擴容到一個很大的值，可能之后很長一段時間都不會用到如此大的空間，就會造成內存的浪費。
總結
雖然使用默認的StringBuilder進行字符串拼接操作，性能消耗不是很嚴重，但在高性能場景下，還是推薦使用ThreadLocal下可重用的StringBuilder方案。
參考資料：
StringBuilder在高性能場景下的正確用法
END。
我是占小狼。
在魔都艱苦奮斗，白天是上班族，晚上是知識服務工作者。
如果讀完覺得有收獲的話，記得關注和點贊哦。
非要打賞的話，我也是不會拒絕的。
