String字元串是系統裡最常用的類型之一，在系統中占據了很大的記憶體，是以，高效地使用字元串，對系統的性能有較好的提升。
針對字元串的優化，我在工作與學習過程總結了以下三種方案作分享：
一.優化建構的超大字元串
驗證環境：jdk1.8
反編譯工具：jad
1.下載下傳反編譯工具jad，百度下載下傳
2.驗證
先執行一段例子1代碼：
public class test3 {
public static void main(String[] args) {
String str="ab"+"cd"+"ef"+"123";
}
} 執行完成後，用反編譯工具jad進行反編譯：jad -o -a -s d.java test.class
反編譯後的代碼：
package example;
public class test
{
public test()
{
// 0 0:aload_0
// 1 1:invokespecial #1 <Method void Object()>
// 2 4:return
}
public static void main(String args[])
{
String str = "abcdef123";
// 0 0:ldc1 #2 <String "abcdef123">
// 1 2:astore_1
// 2 3:return
}
} 案例2：
public class test1 {
public static void main(String[] args)
{
String s = "abc";
String ss = "ok" + s + "xyz" + 5;
System.out.println(ss);
}
} 用反編譯工具jad執行jad -o -a -s d.java test1.class進行反編譯後：
package example;
import java.io.PrintStream;
public class test1
{
public test1()
{
// 0 0:aload_0
// 1 1:invokespecial #1 <Method void Object()>
// 2 4:return
}
public static void main(String args[])
{
String s = "abc";
// 0 0:ldc1 #2 <String "abc">
// 1 2:astore_1
String ss = (new StringBuilder()).append("ok").append(s).append("xyz").append(5).toString();
// 2 3:new #3 <Class StringBuilder>
// 3 6:dup
// 4 7:invokespecial #4 <Method void StringBuilder()>
// 5 10:ldc1 #5 <String "ok">
// 6 12:invokevirtual #6 <Method StringBuilder StringBuilder.append(String)>
// 7 15:aload_1
// 8 16:invokevirtual #6 <Method StringBuilder StringBuilder.append(String)>
// 9 19:ldc1 #7 <String "xyz">
// 10 21:invokevirtual #6 <Method StringBuilder StringBuilder.append(String)>
// 11 24:iconst_5
// 12 25:invokevirtual #8 <Method StringBuilder StringBuilder.append(int)>
// 13 28:invokevirtual #9 <Method String StringBuilder.toString()>
// 14 31:astore_2
System.out.println(ss);
// 15 32:getstatic #10 <Field PrintStream System.out>
// 16 35:aload_2
// 17 36:invokevirtual #11 <Method void PrintStream.println(String)>
// 18 39:return
}
} 根據反編譯結果，可以看到内部其實是通過
StringBuilder進行字元串拼接的。
推薦看下：
java.lang.String 的 + 号操作到底做了什麼？再來執行例3的代碼：
public class test2 {
public static void main(String[] args) {
String s = "";
Random rand = new Random();
for (int i = 0; i < 10; i++) {
s = s + rand.nextInt(1000) + " ";
}
System.out.println(s);
}
} 用反編譯工具jad執行jad -o -a -s d.java test2.class進行反編譯後，發現其内部同樣是通過
來進行拼接的：
package example;
import java.io.PrintStream;
import java.util.Random;
public class test2
{
public test2()
{
// 0 0:aload_0
// 1 1:invokespecial #1 <Method void Object()>
// 2 4:return
}
public static void main(String args[])
{
String s = "";
// 0 0:ldc1 #2 <String "">
// 1 2:astore_1
Random rand = new Random();
// 2 3:new #3 <Class Random>
// 3 6:dup
// 4 7:invokespecial #4 <Method void Random()>
// 5 10:astore_2
for(int i = 0; i < 10; i++)
//* 6 11:iconst_0
//* 7 12:istore_3
//* 8 13:iload_3
//* 9 14:bipush 10
//* 10 16:icmpge 55
s = (new StringBuilder()).append(s).append(rand.nextInt(1000)).append(" ").toString();
// 11 19:new #5 <Class StringBuilder>
// 12 22:dup
// 13 23:invokespecial #6 <Method void StringBuilder()>
// 14 26:aload_1
// 15 27:invokevirtual #7 <Method StringBuilder StringBuilder.append(String)>
// 16 30:aload_2
// 17 31:sipush 1000
// 18 34:invokevirtual #8 <Method int Random.nextInt(int)>
// 19 37:invokevirtual #9 <Method StringBuilder StringBuilder.append(int)>
// 20 40:ldc1 #10 <String " ">
// 21 42:invokevirtual #7 <Method StringBuilder StringBuilder.append(String)>
// 22 45:invokevirtual #11 <Method String StringBuilder.toString()>
// 23 48:astore_1
// 24 49:iinc 3 1
//* 25 52:goto 13
System.out.println(s);
// 26 55:getstatic #12 <Field PrintStream System.out>
// 27 58:aload_1
// 28 59:invokevirtual #13 <Method void PrintStream.println(String)>
// 29 62:return
}
} 綜上案例分析，發現字元串進行“+”拼接時，内部有以下幾種情況：
1.“+”直接拼接的是常量變量，如"ab"+"cd"+"ef"+"123"，内部編譯就把幾個連接配接成一個常量字元串處理；
2. “+”拼接的含變量字元串，如案例2："ok" + s + "xyz" + 5，内部編譯其實是new 一個StringBuilder來進行來通過append進行拼接；
3.案例3循環過程，實質也是“+”拼接含變量字元串，是以，内部編譯時，也會建立StringBuilder來進行拼接。
對比三種情況，發現第三種情況每次做循環，都會新建立一個StringBuilder對象，這會增加系統的記憶體，反過來就會降低系統性能。
是以，在做字元串拼接時，單線程環境下，可以顯性使用StringBuilder來進行拼接，避免每循環一次就new一個StringBuilder對象；在多線程環境下，可以使用線程安全的StringBuffer，但涉及到鎖競争，StringBuffer性能會比StringBuilder差一點。
這樣，起到在字元串拼接時的優化效果。
二.如何使用String.intern節省記憶體？
在回答這個問題之前，可以先對一段代碼進行測試：
1.首先在idea設定-XX:+PrintGCDetails -Xmx6G -Xmn3G，用來列印GC日志資訊，設定如下圖所示：
2.執行以下例子代碼：
public class test4 {
public static void main(String[] args) {
final int MAX=10000000;
System.out.println("不用intern："+notIntern(MAX));
System.out.println("使用intern："+intern(MAX));
}
private static long notIntern(int MAX){
long start = System.currentTimeMillis();
for (int i = 0; i < MAX; i++) {
int j = i % 100;
String str = String.valueOf(j);
}
return System.currentTimeMillis() - start;
}
private static long intern(int MAX){
long start = System.currentTimeMillis();
for (int i = 0; i < MAX; i++) {
int j = i % 100;
String str = String.valueOf(j).intern();
}
return System.currentTimeMillis() - start;
}
} 未使用intern的GC日志：
[GC (System.gc()) [PSYoungGen: 377487K->760K(2752512K)] 377487K->768K(2758656K), 0.0009102 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
[Full GC (System.gc()) [PSYoungGen: 760K->0K(2752512K)] [ParOldGen: 8K->636K(6144K)] 768K->636K(2758656K), [Metaspace: 3278K->3278K(1056768K)], 0.0051214 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
Heap
PSYoungGen total 2752512K, used 23593K [0x0000000700000000, 0x00000007c0000000, 0x00000007c0000000)
eden space 2359296K, 1% used [0x0000000700000000,0x000000070170a548,0x0000000790000000)
from space 393216K, 0% used [0x0000000790000000,0x0000000790000000,0x00000007a8000000)
to space 393216K, 0% used [0x00000007a8000000,0x00000007a8000000,0x00000007c0000000)
ParOldGen total 6144K, used 636K [0x0000000640000000, 0x0000000640600000, 0x0000000700000000)
object space 6144K, 10% used [0x0000000640000000,0x000000064009f2f8,0x0000000640600000)
Metaspace used 3284K, capacity 4500K, committed 4864K, reserved 1056768K
class space used 359K, capacity 388K, committed 512K, reserved 1048576K 根據列印的日志分析：沒有使用intern情況下，執行時間為354ms，占用記憶體為24229k，推薦閱讀：
46張PPT弄懂JVM。
使用intern的GC日志：
[GC (System.gc()) [PSYoungGen: 613417K->1144K(2752512K)] 613417K->1152K(2758656K), 0.0012530 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
[Full GC (System.gc()) [PSYoungGen: 1144K->0K(2752512K)] [ParOldGen: 8K->965K(6144K)] 1152K->965K(2758656K), [Metaspace: 3780K->3780K(1056768K)], 0.0079962 secs] [Times: user=0.02 sys=0.00, real=0.01 secs]
Heap
PSYoungGen total 2752512K, used 15729K [0x0000000700000000, 0x00000007c0000000, 0x00000007c0000000)
eden space 2359296K, 0% used [0x0000000700000000,0x0000000700f5c400,0x0000000790000000)
from space 393216K, 0% used [0x0000000790000000,0x0000000790000000,0x00000007a8000000)
to space 393216K, 0% used [0x00000007a8000000,0x00000007a8000000,0x00000007c0000000)
ParOldGen total 6144K, used 965K [0x0000000640000000, 0x0000000640600000, 0x0000000700000000)
object space 6144K, 15% used [0x0000000640000000,0x00000006400f1740,0x0000000640600000)
Metaspace used 3786K, capacity 4540K, committed 4864K, reserved 1056768K
class space used 420K, capacity 428K, committed 512K, reserved 1048576K 日志分析：沒有使用intern情況下，執行時間為1515ms，占用記憶體為16694k;
綜上所述:使用intern情況下，記憶體相對沒有使用intern的情況要小，但在節省記憶體的同時，增加了時間複雜度。我試過将MAX=10000000再增加一個0的情況下，使用intern将會花費高達11秒的執行時間，可見，在周遊資料過大時，不建議使用intern。
是以，使用intern的前提，一定要考慮到具體的使用場景。
到這裡，可以确定，使用String.intern确實可以節省記憶體。
接下來，分析一下intern在不同JDK版本的差別。
在JDK1.6中，字元串常量池在方法區中，方法區屬于永久代。
在JDK1.7中，字元串常量池移到了堆中。
在JDK1.8中，字元串常量池移到了元空間裡，與堆相獨立。
分别在1.6、1.7、1.8版本執行以下一個例子：
public class test5 {
public static void main(String[] args) {
String s1=new String("ab");
s.intern();
String s2="ab";
System.out.println(s1==s2);
String s3=new String("ab")+new String("cd");
s3.intern();
String s4="abcd";
System.out.println(s4==s3);
}
} 1.6版本
執行結果：
fasle false
分析：
執行第一部分時：
1.代碼編譯時，先在字元串常量池裡建立常量“ab"；在調用new時，将在堆中建立一個String對象，字元串常量建立的“ab"存儲到堆中，最後堆中的String對象傳回一個引用給s1。
2.s.intern()，在字元串常量池裡已經存在“ab”,便不再建立存放副本“ab"；
3.s2="ab"，s2指向的是字元串常量池裡”ab"，而s1指向的堆中的”ab"，故兩者不相等。5 個刁鑽的 String 面試題！建議看下。
關注微信公衆号：Java技術棧，在背景回複：面試，可以擷取我整理的 N 篇 Java 面試題幹貨。
該示意圖如下：
執行第二部分：
1.兩個new出來相加的“abcd”存放在堆中，s3指向堆中的“abcd";
2.執行s3.intern()，在将“abcd"副本的存放到字元串常量池時，發現常量池裡沒有該”abcd"，是以，成功存放；
3.s4="abcd"指向的是字元串常量池裡已有的“abcd"副本，而s3指向的是堆中的"abcd"，副本"abcd"的位址和堆中“abcd"位址不相同，故為false;
1.7版本
false true
執行第一部分：這一部分與jdk1.6基本類似，不同在于，s1.intern()傳回的是引用，而不是副本。
1.new String("ab")+new String("cd")，先在常量池裡生成“ab"和”cd"，再在堆中生成“abcd";
2.執行s3.intern()時，會把“abcd”的對象引用放到字元串常量池裡，發現常量池裡還沒有該引用，故可成功放入。當String s4="abcd"，即把字元串常量池中”abcd“的引用位址指派給s4，相當于s4指向了堆中”abcd"的位址，故s3==s4為true。
1.8版本
參考網上一些部落格，在1.8版本當中，使用intern()時，執行原理如下：
若字元串常量池中，包含了與目前對象相當的字元串，将傳回常量池裡的字元串；若不存在，則将該字元串存放進常量池裡，并傳回字元串的引用。
綜上所述，可見三種版本當中，使用intern時，若字元串常量池裡不存在相應字元串時，存在以下差別：
例如：
String s1=new String("ab"); s.intern();
jdk1.6:若字元串常量池裡沒有“ab"，則會在常量池裡存放一個“ab"副本，該副本位址與堆中的”ab"位址不相等；
jdk1.7:若字元串常量池裡沒有“ab"，會将“ab”的對象引用放到字元串常量池裡，該引用位址與堆中”ab"的位址相同；
jdk1.8:若字元串常量池中包含與目前對象相當的字元串，将傳回常量池裡的字元串；若不存在，則将該字元串存放進常量池裡，并傳回字元串的引用。
三.如何使用字元串的分割方法？
在簡單進行字元串分割時，可以用indexOf替代split，因為split的性能不夠穩定，故針對簡單的字元串分割，可優先使用indexOf代替；