String字符串性能優(yōu)化的幾種方案
閱讀文本大概需要10分鐘。
作者：朱季謙
來源：https://www.cnblogs.com/zhujiqian/p/12202951.html
String字符串是系統(tǒng)里最常用的類型之一，在系統(tǒng)中占據(jù)了很大的內(nèi)存，因此，高效地使用字符串，對(duì)系統(tǒng)的性能有較好的提升。
針對(duì)字符串的優(yōu)化，我在工作與學(xué)習(xí)過程總結(jié)了以下三種方案作分享：
一.優(yōu)化構(gòu)建的超大字符串
驗(yàn)證環(huán)境：jdk1.8
反編譯工具：jad
1.下載反編譯工具jad，百度云盤下載：
鏈接：https://pan.baidu.com/s/1TK1_N769NqtDtLn28jR-Xg
提取碼：ilil
2.驗(yàn)證
先執(zhí)行一段例子1代碼：
public class test3 {public static void main(String[] args) {String str="ab"+"cd"+"ef"+"123";}}
執(zhí)行完成后，用反編譯工具jad進(jìn)行反編譯：jad -o -a -s d.java test.class
反編譯后的代碼：
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.// Jad home page: http://www.kpdus.com/jad.html// Decompiler options: packimports(3) annotate// Source File Name: test.javapackage example;public class test{public test(){// 0 0:aload_0// 1 1:invokespecial #1// 2 4:return}public static void main(String args[]){String str = "abcdef123";// 0 0:ldc1 #2// 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執(zhí)行jad -o -a -s d.java test1.class進(jìn)行反編譯后：
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.// Jad home page: http://www.kpdus.com/jad.html// Decompiler options: packimports(3) annotate// Source File Name: test1.javapackage example;import java.io.PrintStream;public class test1{public test1(){// 0 0:aload_0// 1 1:invokespecial #1// 2 4:return}public static void main(String args[]){String s = "abc";// 0 0:ldc1 #2// 1 2:astore_1String ss = (new StringBuilder()).append("ok").append(s).append("xyz").append(5).toString();// 2 3:new #3// 3 6:dup// 4 7:invokespecial #4// 5 10:ldc1 #5// 6 12:invokevirtual #6// 7 15:aload_1// 8 16:invokevirtual #6// 9 19:ldc1 #7// 10 21:invokevirtual #6// 11 24:iconst_5// 12 25:invokevirtual #8// 13 28:invokevirtual #9// 14 31:astore_2System.out.println(ss);// 15 32:getstatic #10// 16 35:aload_2// 17 36:invokevirtual #11// 18 39:return}}
根據(jù)反編譯結(jié)果，可以看到內(nèi)部其實(shí)是通過StringBuilder進(jìn)行字符串拼接的。
再來執(zhí)行例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執(zhí)行jad -o -a -s d.java test2.class進(jìn)行反編譯后，發(fā)現(xiàn)其內(nèi)部同樣是通過StringBuilder來進(jìn)行拼接的：
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.// Jad home page: http://www.kpdus.com/jad.html// Decompiler options: packimports(3) annotate// Source File Name: test2.javapackage example;import java.io.PrintStream;import java.util.Random;public class test2{public test2(){// 0 0:aload_0// 1 1:invokespecial #1// 2 4:return}public static void main(String args[]){String s = "";// 0 0:ldc1 #2// 1 2:astore_1Random rand = new Random();// 2 3:new #3// 3 6:dup// 4 7:invokespecial #4// 5 10:astore_2for(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 55s = (new StringBuilder()).append(s).append(rand.nextInt(1000)).append(" ").toString();// 11 19:new #5// 12 22:dup// 13 23:invokespecial #6// 14 26:aload_1// 15 27:invokevirtual #7// 16 30:aload_2// 17 31:sipush 1000// 18 34:invokevirtual #8// 19 37:invokevirtual #9// 20 40:ldc1 #10// 21 42:invokevirtual #7// 22 45:invokevirtual #11// 23 48:astore_1// 24 49:iinc 3 1//* 25 52:goto 13System.out.println(s);// 26 55:getstatic #12// 27 58:aload_1// 28 59:invokevirtual #13// 29 62:return}}
綜上案例分析，發(fā)現(xiàn)字符串進(jìn)行“+”拼接時(shí)，內(nèi)部有以下幾種情況：
1.“+”直接拼接的是常量變量，如"ab"+"cd"+"ef"+"123"，內(nèi)部編譯就把幾個(gè)連接成一個(gè)常量字符串處理；
2. “+”拼接的含變量字符串，如案例2："ok" + s + "xyz" + 5，內(nèi)部編譯其實(shí)是new 一個(gè)StringBuilder來進(jìn)行來通過append進(jìn)行拼接；
3.案例3循環(huán)過程，實(shí)質(zhì)也是“+”拼接含變量字符串，因此，內(nèi)部編譯時(shí)，也會(huì)創(chuàng)建StringBuilder來進(jìn)行拼接。
對(duì)比三種情況，發(fā)現(xiàn)第三種情況每次做循環(huán)，都會(huì)新創(chuàng)建一個(gè)StringBuilder對(duì)象，這會(huì)增加系統(tǒng)的內(nèi)存，反過來就會(huì)降低系統(tǒng)性能。
因此，在做字符串拼接時(shí)，單線程環(huán)境下，可以顯性使用StringBuilder來進(jìn)行拼接，避免每循環(huán)一次就new一個(gè)StringBuilder對(duì)象；在多線程環(huán)境下，可以使用線程安全的StringBuffer，但涉及到鎖競爭，StringBuffer性能會(huì)比StringBuilder差一點(diǎn)。
這樣，起到在字符串拼接時(shí)的優(yōu)化效果。
2.如何使用String.intern節(jié)省內(nèi)存？
在回答這個(gè)問題之前，可以先對(duì)一段代碼進(jìn)行測試：
1.首先在idea設(shè)置-XX:+PrintGCDetails -Xmx6G -Xmn3G，用來打印GC日志信息，設(shè)置如下圖所示：
2.執(zhí)行以下例子代碼：
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日志：
不用intern：354[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]HeapPSYoungGen 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 1056768Kclass space used 359K, capacity 388K, committed 512K, reserved 1048576K
根據(jù)打印的日志分析：沒有使用intern情況下，執(zhí)行時(shí)間為354ms，占用內(nèi)存為24229k;
使用intern的GC日志：
使用intern：1515[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]HeapPSYoungGen 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 1056768Kclass space used 420K, capacity 428K, committed 512K, reserved 1048576K
日志分析：沒有使用intern情況下，執(zhí)行時(shí)間為1515ms，占用內(nèi)存為16694k;
綜上所述:使用intern情況下，內(nèi)存相對(duì)沒有使用intern的情況要小，但在節(jié)省內(nèi)存的同時(shí)，增加了時(shí)間復(fù)雜度。我試過將MAX=10000000再增加一個(gè)0的情況下，使用intern將會(huì)花費(fèi)高達(dá)11秒的執(zhí)行時(shí)間，可見，在遍歷數(shù)據(jù)過大時(shí)，不建議使用intern。
因此，使用intern的前提，一定要考慮到具體的使用場景。
到這里，可以確定，使用String.intern確實(shí)可以節(jié)省內(nèi)存。
接下來，分析一下intern在不同JDK版本的區(qū)別。
在JDK1.6中，字符串常量池在方法區(qū)中，方法區(qū)屬于永久代。
在JDK1.7中，字符串常量池移到了堆中。
在JDK1.8中，字符串常量池移到了元空間里，與堆相獨(dú)立。
分別在1.6、1.7、1.8版本執(zhí)行以下一個(gè)例子：
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版本
執(zhí)行結(jié)果：
fasle false
分析：
執(zhí)行第一部分時(shí)：
1.代碼編譯時(shí)，先在字符串常量池里創(chuàng)建常量“ab"；在調(diào)用new時(shí)，將在堆中創(chuàng)建一個(gè)String對(duì)象，字符串常量創(chuàng)建的“ab"存儲(chǔ)到堆中，最后堆中的String對(duì)象返回一個(gè)引用給s1。
2.s.intern()，在字符串常量池里已經(jīng)存在“ab”,便不再創(chuàng)建存放副本“ab"；
3.s2="ab"，s2指向的是字符串常量池里”ab"，而s1指向的堆中的”ab"，故兩者不相等。
該示意圖如下：
執(zhí)行第二部分：
1.兩個(gè)new出來相加的“abcd”存放在堆中，s3指向堆中的“abcd";
2.執(zhí)行s3.intern()，在將“abcd"副本的存放到字符串常量池時(shí)，發(fā)現(xiàn)常量池里沒有該”abcd"，因此，成功存放；
3.s4="abcd"指向的是字符串常量池里已有的“abcd"副本，而s3指向的是堆中的"abcd"，副本"abcd"的地址和堆中“abcd"地址不相同，故為false;
1.7版本
false true
執(zhí)行第一部分：這一部分與jdk1.6基本類似，不同在于，s1.intern()返回的是引用，而不是副本。
執(zhí)行第二部分：
1.new String("ab")+new String("cd")，先在常量池里生成“ab"和”cd"，再在堆中生成“abcd";
2.執(zhí)行s3.intern()時(shí)，會(huì)把“abcd”的對(duì)象引用放到字符串常量池里，發(fā)現(xiàn)常量池里還沒有該引用，故可成功放入。當(dāng)String s4="abcd"，即把字符串常量池中”abcd“的引用地址賦值給s4，相當(dāng)于s4指向了堆中”abcd"的地址，故s3==s4為true。
1.8版本
false true
參考網(wǎng)上一些博客，在1.8版本當(dāng)中，使用intern()時(shí)，執(zhí)行原理如下：
若字符串常量池中，包含了與當(dāng)前對(duì)象相當(dāng)?shù)淖址瑢⒎祷爻Ａ砍乩锏淖址?/span>若不存在，則將該字符串存放進(jìn)常量池里，并返回字符串的引用。
?
綜上所述，可見三種版本當(dāng)中，使用intern時(shí)，若字符串常量池里不存在相應(yīng)字符串時(shí)，存在以下區(qū)別：
例如：
String s1=new String("ab"); s.intern();
jdk1.6:若字符串常量池里沒有“ab"，則會(huì)在常量池里存放一個(gè)“ab"副本，該副本地址與堆中的”ab"地址不相等；
jdk1.7:若字符串常量池里沒有“ab"，會(huì)將“ab”的對(duì)象引用放到字符串常量池里，該引用地址與堆中”ab"的地址相同；
jdk1.8:若字符串常量池中包含與當(dāng)前對(duì)象相當(dāng)?shù)淖址瑢⒎祷爻Ａ砍乩锏淖址?/strong>若不存在，則將該字符串存放進(jìn)常量池里，并返回字符串的引用。
3.如何使用字符串的分割方法？
在簡單進(jìn)行字符串分割時(shí)，可以用indexOf替代split，因?yàn)閟plit的性能不夠穩(wěn)定，故針對(duì)簡單的字符串分割，可優(yōu)先使用indexOf代替；
最后免費(fèi)給大家分享50個(gè)Java項(xiàng)目實(shí)戰(zhàn)資料，涵蓋入門、進(jìn)階各個(gè)階段學(xué)習(xí)內(nèi)容，可以說非常全面了。大部分視頻還附帶源碼，學(xué)起來還不費(fèi)勁！
附上截圖。（下面有下載方式）。
項(xiàng)目領(lǐng)取方式：
掃描下方公眾號(hào)回復(fù)：50，
可獲取下載鏈接
???
?長按上方二維碼?2 秒 回復(fù)「50」即可獲取資料
點(diǎn)贊是最大的支持?