一、String的基本特性

String：字符串，使用一對""引起來表示。
String sl = “hello”；//字面量的定義方式
String s2 = new String（“hello”）

String聲明為final的,不可被繼承

String實(shí)現(xiàn)了Serializable接口：表示字符串是支持序列化的。 實(shí)現(xiàn)了Comparable接口：表示String可以比較大小

String在jdk8及以前內(nèi)部定義了final char[],value用于存儲(chǔ)字符串?dāng)?shù)據(jù)。jdk9時(shí)改為byte[ ]

public final class String implements java.io.Serializable， Comparable<String>,CharSequence { @Stable private final byte[] value； }

String：代表不可變的字符序列。簡稱：不可變性。

通過字面量的方式（區(qū)別于new）給一個(gè)字符串賦值，此時(shí)的字符串值聲明在字符串常量池中

字符串常量池中是不會(huì)存儲(chǔ)相同內(nèi)容的字符串的

• 1.String的String Pool 是一個(gè)固定大小的Hashtable，默認(rèn)值大小長度是1009。如果放進(jìn)StringPool的String非常多，就會(huì)造成Hash沖突嚴(yán)重，從而導(dǎo)致鏈表會(huì)很長，而鏈表長了后直接會(huì)造成的影響就是當(dāng)調(diào)用String. intern時(shí)性能會(huì)大幅下降。
• 2.使用 -XX:StringTableSize可設(shè)置StringTable的長度
• 3.在jdk6中StringTable是固定的，就是1009的長度，所以如果常量池中的字符串過多就會(huì)導(dǎo)致效率下降很快。StringTableSize設(shè) 置沒有要求
• 4.在jdk7中，StringTable的長度默認(rèn)值是60013
• 5.jdk8開始,1009是StringTable長度可設(shè)置的最小值

二、String的內(nèi)存分配

常量池就類似一個(gè)Java系統(tǒng)級別提供的緩存。8種基本數(shù)據(jù)類型的常量池都是系統(tǒng)協(xié)調(diào)的，String類型的常量池比較特殊。它的主要使用方法有兩種：

• 1.直接使用雙引號聲明出來的String對象會(huì)直接存儲(chǔ)在常量池中(比如： String info = “abc” )
• 2.如果不是用雙引號聲明的String對象，可以使用String提供的intern（）方法

String的基本操作

class Memory {public static void main(String[] args) {//line 1int i = 1;//line 2Object obj = new Object();//line 3Memory mem = new Memory();//line 4mem.foo(obj);//line 5}//line 9private void foo(Object param) {//line 6String str = param.toString();//line 7System.out.println(str);}//line 8 }

三、字符串拼接操作

常量與常量的拼接結(jié)果在常量池，原理是編譯期優(yōu)化

常量池中不會(huì)存在相同內(nèi)容的常量。

只要其中有一個(gè)是變量，結(jié)果就在堆中

(只有有一個(gè)是變量,那么它會(huì)在堆中創(chuàng)建一個(gè)StringBuilder，調(diào)用append( )方法進(jìn)行添加操作，調(diào)用toString( )方法轉(zhuǎn)換為字符串【toString( )方法其實(shí)就是:new String( )】)

如果拼接的結(jié)果調(diào)用intern（）方法分為兩種情況：

• 1.JDK1.6，將這個(gè)字符串對象嘗試放入串池
  ①. 如果字符串常量池中有，則并不會(huì)放入。返回已有的串池中的對象的地址
  ②.如果沒有,它會(huì)在常量池中創(chuàng)建一個(gè)對象放入串池中，并返回串池中的對象地址
• 2.JDK1.7，將這個(gè)字符串對象嘗試放入串池
  ①. 如果字符串常量池中有，則并不會(huì)放入。返回已有的串池中的對象的地址
  ②. 如果沒有，它不會(huì)創(chuàng)建一個(gè)對象，如果堆中已經(jīng)這個(gè)字符串，那么會(huì)將堆中的引用地址賦給它
• 3.test3、test4重點(diǎn)掌握

@Test public void test1(){String s1 = "a" + "b" + "c";//編譯期優(yōu)化：等同于"abc" 在字節(jié)碼文件中,s1="abc"String s2 = "abc"; //"abc"一定是放在字符串常量池中，將此地址賦給s2/** 最終.java編譯成.class,再執(zhí)行.class* String s1 = "abc";* String s2 = "abc"*/System.out.println(s1 == s2); //trueSystem.out.println(s1.equals(s2)); //true }@Test public void test2(){String s1 = "javaEE";String s2 = "hadoop";String s3 = "javaEEhadoop";String s4 = "javaEE" + "hadoop";//編譯期優(yōu)化//如果拼接符號的前后出現(xiàn)了變量，則相當(dāng)于在堆空間中new String()，具體的內(nèi)容為拼接的結(jié)果：javaEEhadoopString s5 = s1 + "hadoop";String s6 = "javaEE" + s2;String s7 = s1 + s2;System.out.println(s3 == s4);//trueSystem.out.println(s3 == s5);//falseSystem.out.println(s3 == s6);//falseSystem.out.println(s3 == s7);//falseSystem.out.println(s5 == s6);//falseSystem.out.println(s5 == s7);//falseSystem.out.println(s6 == s7);//false//intern():判斷字符串常量池中是否存在javaEEhadoop值，如果存在，則返回常量池中javaEEhadoop的地址；//如果字符串常量池中不存在javaEEhadoop，則在常量池中加載一份javaEEhadoop，并返回次對象的地址。String s8 = s6.intern();System.out.println(s3 == s8);//true } @Test public void test3(){String s1 = "a";String s2 = "b";String s3 = "ab";/*如下的s1 + s2 的執(zhí)行細(xì)節(jié)：(變量s是我臨時(shí)定義的）① StringBuilder s = new StringBuilder();② s.append("a")③ s.append("b")④ s.toString() --> 約等于 new String("ab")補(bǔ)充：在jdk5.0之后使用的是StringBuilder,在jdk5.0之前使用的是StringBuffer*/String s4 = s1 + s2;//System.out.println(s3 == s4);//false }/* 1. 字符串拼接操作不一定使用的是StringBuilder!如果拼接符號左右兩邊都是字符串常量或常量引用，則仍然使用編譯期優(yōu)化，即非StringBuilder的方式。 2. 針對于final修飾類、方法、基本數(shù)據(jù)類型、引用數(shù)據(jù)類型的量的結(jié)構(gòu)時(shí)，能使用上final的時(shí)候建議使用上。*/ @Test public void test4(){final String s1 = "a";final String s2 = "b";String s3 = "ab";String s4 = s1 + s2;System.out.println(s3 == s4);//true }//練習(xí)： @Test public void test5(){String s1 = "javaEEhadoop";String s2 = "javaEE";String s3 = s2 + "hadoop";System.out.println(s1 == s3);//falsefinal String s4 = "javaEE";//s4:常量String s5 = s4 + "hadoop";System.out.println(s1 == s5);//true}

四、拼接操作與append的效率對比

append效率要比字符串拼接高很多

/*體會(huì)執(zhí)行效率：通過StringBuilder的append()的方式添加字符串的效率要遠(yuǎn)高于使用String的字符串拼接方式！詳情：① StringBuilder的append()的方式：自始至終中只創(chuàng)建過一個(gè)StringBuilder的對象使用String的字符串拼接方式：創(chuàng)建過多個(gè)StringBuilder和String的對象② 使用String的字符串拼接方式：內(nèi)存中由于創(chuàng)建了較多的StringBuilder和String的對象，內(nèi)存占用更大；如果進(jìn)行GC，需要花費(fèi)額外的時(shí)間。改進(jìn)的空間：在實(shí)際開發(fā)中，如果基本確定要前前后后添加的字符串長度不高于某個(gè)限定值highLevel的情況下,建議使用構(gòu)造器實(shí)例化：StringBuilder s = new StringBuilder(highLevel);//new char[highLevel]*/@Testpublic void test6(){long start = System.currentTimeMillis();// method1(100000);//4014method2(100000);//7long end = System.currentTimeMillis();System.out.println("花費(fèi)的時(shí)間為：" + (end - start));}public void method1(int highLevel){String src = "";for(int i = 0;i < highLevel;i++){src = src + "a";//每次循環(huán)都會(huì)創(chuàng)建一個(gè)StringBuilder、String} // System.out.println(src);}public void method2(int highLevel){//只需要?jiǎng)?chuàng)建一個(gè)StringBuilderStringBuilder src = new StringBuilder();for (int i = 0; i < highLevel; i++) {src.append("a");} // System.out.println(src);}

五、intern()的使用 (超級重要)

前言：

• (1). 如果不是用雙引號聲明的String對象，可以使用String提供的intern方法：intern方法會(huì)從字符串常量池中查詢當(dāng)前字符串是否存在，若不存在就會(huì)將當(dāng)前字符串放入常量池中
• (2). 比如： String myInfo = new String(“I love u”).intern()； 也就是說，如果在任意字符串上調(diào)用String. intern方法，那么其返回結(jié)果所指向的那個(gè)類實(shí)例，必須和直接以常量形式出現(xiàn)的字符串實(shí)例完全相同。因此，下 列表達(dá)式的值必定是true：（“a” + “b” + “c”）.intern（）== “abc”;
• (3). 通俗點(diǎn)講，Interned String就是確保字符串在內(nèi)存里只有一份拷貝，這樣可以節(jié)約內(nèi)存空間，加快字符串操作任務(wù)的執(zhí)行速度。注意，這個(gè)值會(huì)被存放在字符串內(nèi)部池（String
  Intern Pool）

new String(“ab”)會(huì)創(chuàng)建幾個(gè)對象
①. new String(“ab”)會(huì)創(chuàng)建幾個(gè)對象 很重要
(new String(“ab”)會(huì)創(chuàng)建幾個(gè)對象？看字節(jié)碼，就知道是兩個(gè))

一個(gè)對象是：new關(guān)鍵字在堆空間創(chuàng)建的

另一個(gè)對象是：字符串常量池中的對象"ab"。 字節(jié)碼指令：ldc

如下圖：(常量池中已經(jīng)有了該對象)

new String(“a”) + new String(“b”)創(chuàng)建幾個(gè)對象呢？
②. new String(“a”) + new String(“b”)呢？ 很重要
(在常量池中是沒有ab存在的 [很關(guān)鍵] )

• 對象1：new StringBuilder()

• 對象2： new String(“a”)

• 對象3： 常量池中的"a"

• 對象4： new String(“b”)

• 對象5： 常量池中的"b"
  

• 深入剖析： StringBuilder的toString(): 對象6 ：new String(“ab”)

• 注意：強(qiáng)調(diào)一下，toString()的調(diào)用，在字符串常量池中，沒有生成"ab" 沒有l(wèi)dc指令
  

關(guān)于String.intern( )的面試題

/*** 如何保證變量s指向的是字符串常量池中的數(shù)據(jù)呢？* 有兩種方式：* 方式一： String s = "shkstart";//字面量定義的方式* 方式二： 調(diào)用intern()* String s = new String("shkstart").intern();* String s = new StringBuilder("shkstart").toString().intern();* */ public class StringIntern {public static void main(String[] args) {String s = new String("1");String s1 = s.intern();//調(diào)用此方法之前，字符串常量池中已經(jīng)存在了"1"String s2 = "1";//s 指向堆空間"1"的內(nèi)存地址//s1 指向字符串常量池中"1"的內(nèi)存地址//s2 指向字符串常量池已存在的"1"的內(nèi)存地址 所以 s1==s2System.out.println(s == s2);//jdk6：false jdk7/8：falseSystem.out.println(s1 == s2);//jdk6: true jdk7/8：trueSystem.out.println(System.identityHashCode(s));//491044090System.out.println(System.identityHashCode(s1));//644117698System.out.println(System.identityHashCode(s2));//644117698//s3變量記錄的地址為：new String("11")String s3 = new String("1") + new String("1");//執(zhí)行完上一行代碼以后，字符串常量池中，是否存在"11"呢？答案：不存在！！//在字符串常量池中生成"11"。如何理解：jdk6:創(chuàng)建了一個(gè)新的對象"11",也就有新的地址。//jdk7:此時(shí)常量中并沒有創(chuàng)建"11",而是創(chuàng)建一個(gè)指向堆空間中new String("11")的地址s3.intern();//s4變量記錄的地址：使用的是上一行代碼代碼執(zhí)行時(shí)，在常量池中生成的"11"的地址String s4 = "11";System.out.println(s3 == s4);//jdk6：false jdk7/8：true} }

public class StringIntern1 {public static void main(String[] args) {//StringIntern.java中練習(xí)的拓展：String s3 = new String("1") + new String("1");//new String("11")//執(zhí)行完上一行代碼以后，字符串常量池中，是否存在"11"呢？答案：不存在！！String s4 = "11";//在字符串常量池中生成對象"11"String s5 = s3.intern();System.out.println(s3 == s4);//falseSystem.out.println(s5 == s4);//true} }

四、總結(jié)String的intern（）的使用

如果拼接的結(jié)果調(diào)用intern（）方法分為兩種情況：

• JDK1.6，將這個(gè)字符串對象嘗試放入串池
  ①. 如果字符串常量池中有，則并不會(huì)放入。返回已有的串池中的對象的地址
  ②.如果沒有,它會(huì)在常量池中創(chuàng)建一個(gè)對象放入串池中，并返回串池中的對象地址
• JDK1.7，將這個(gè)字符串對象嘗試放入串池
  ①.如果字符串常量池中有，則并不會(huì)放入。返回已有的串池中的對象的地址
  ②.如果沒有，它不會(huì)創(chuàng)建一個(gè)對象，如果堆中已經(jīng)這個(gè)字符串，那么會(huì)將堆中的引用地址賦給它

public class StringExer1 {public static void main(String[] args) {//String x = "ab";String s = new String("a") + new String("b");//new String("ab")//在上一行代碼執(zhí)行完以后，字符串常量池中并沒有"ab"String s2 = s.intern();//jdk6中：在串池中創(chuàng)建一個(gè)字符串"ab"//jdk8中：串池中沒有創(chuàng)建字符串"ab",而是創(chuàng)建一個(gè)引用，指向new String("ab")，將此引用返回System.out.println(s2 == "ab");//jdk6:true jdk8:trueSystem.out.println(s == "ab");//jdk6:false jdk8:true} }

intern題目：

六、intern()效率測試

大的網(wǎng)站平臺(tái)，需要內(nèi)存中存儲(chǔ)大量的字符串。比如社交網(wǎng)站，很多人都存儲(chǔ)：北京市、海淀區(qū)等信息。這時(shí)候如果字符串都調(diào)用 intern（）方法，就會(huì)明顯降低內(nèi)存的大小。

/*** 使用intern()測試執(zhí)行效率：空間使用上** 結(jié)論：對于程序中大量存在存在的字符串，尤其其中存在很多重復(fù)字符串時(shí)，使用intern()可以節(jié)省內(nèi)存空間。**/ public class StringIntern2 {static final int MAX_COUNT = 1000 * 10000;static final String[] arr = new String[MAX_COUNT];public static void main(String[] args) {Integer[] data = new Integer[]{1,2,3,4,5,6,7,8,9,10};long start = System.currentTimeMillis();for (int i = 0; i < MAX_COUNT; i++) { // arr[i] = new String(String.valueOf(data[i % data.length]));arr[i] = new String(String.valueOf(data[i % data.length])).intern();}long end = System.currentTimeMillis();System.out.println("花費(fèi)的時(shí)間為：" + (end - start));try {Thread.sleep(1000000);} catch (InterruptedException e) {e.printStackTrace();}System.gc();} }

七、 StrtingTable的垃圾回收(了解)

/*** String的垃圾回收:* -Xms15m -Xmx15m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails**/ public class StringGCTest {public static void main(String[] args) { // for (int j = 0; j < 100; j++) { // String.valueOf(j).intern(); // }//發(fā)生垃圾回收行為for (int j = 0; j < 100000; j++) {String.valueOf(j).intern();}} }

總結(jié)

以上是生活随笔為你收集整理的JVM_04 字符串常量池(详解intern( ))的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。