在翻《深刻理解Java虛擬機》的書時,又看到了2-7的 String.intern()返回引用的測試。java
總結一句話:面試
jdk1.7以前,調用intern()方法會判斷常量池是否有該字符串,有,返回常量池引用,沒有,常量池中建立並返回引用給intern方法。app
jdk1.7以後,調用intern()方法會判斷常量池是否有該字符串,有,返回常量池引用,沒有,常量池中保存當前對象的引用。jvm
其實要搞明白String.intern(),我總結了下面幾條規則:
1、jdk1.7以前,new String都是在堆上建立字符串對象。當調用 intern() 方法時,編譯器會將字符串添加到常量池中(stringTable維護),並返回指向該常量的引用。 測試
2、經過字面量賦值建立字符串(如:String str=」twm」)時,會先在常量池中查找是否存在相同的字符串,若存在,則將棧中的引用直接指向該字符串;若不存在,則在常量池中生成一個字符串,再將棧中的引用指向該字符串。 優化
3、常量字符串的「+」操做,編譯階段直接會合成爲一個字符串。如string str=」JA」+」VA」,在編譯階段會直接合併成語句String str=」JAVA」,因而會去常量池中查找是否存在」JAVA」,從而進行建立或引用。ui
4、對於final字段,編譯期直接進行了常量替換(而對於非final字段則是在運行期進行賦值處理的)。
final String str1=」ja」;
final String str2=」va」;
String str3=str1+str2;
在編譯時,直接替換成了String str3=」ja」+」va」,根據第三條規則,再次替換成String str3=」JAVA」spa
5、常量字符串和變量拼接時(如:String str3=baseStr + 「01」;)會調用stringBuilder.append()在堆上建立新的對象。.net
6、JDK 1.7後,intern方法仍是會先去查詢常量池中是否有已經存在,若是存在,則返回常量池中的引用,這一點與以前沒有區別,區別在於,若是在常量池找不到對應的字符串,則不會再將字符串拷貝到常量池,而只是在常量池中生成一個對原字符串的引用。簡單的說,就是往常量池放的東西變了:原來在常量池中找不到時,複製一個副本放到常量池,1.7後則是將在堆上的地址引用複製到常量池。 code
舉例說明:
String str2 = new String("str")+new String("01"); str2.intern(); String str1 = "str01"; System.out.println(str2==str1);
在JDK 1.7下,當執行str2.intern();時,由於常量池中沒有「str01」這個字符串,因此會在常量池中生成一個對堆中的「str01」的引用(注意這裏是引用 ,就是這個區別於JDK 1.6的地方。在JDK1.6下是生成原字符串的拷貝),而在進行String str1 = 「str01」;字面量賦值的時候,常量池中已經存在一個引用,因此直接返回了該引用,所以str1和str2都指向堆中的同一個字符串,返回true。
String str2 = new String("str")+new String("01"); String str1 = "str01"; str2.intern(); System.out.println(str2==str1);
將中間兩行調換位置之後,由於在進行字面量賦值(String str1 = 「str01″)的時候,常量池中不存在,因此str1指向的常量池中的位置,而str2指向的是堆中的對象,再進行intern方法時,對str1和str2已經沒有影響了,因此返回false。
常見試題解答
有了對以上的知識的瞭解,咱們如今再來看常見的面試或筆試題就很簡單了:
Q:下列程序的輸出結果:
String s1 = 「abc」;
String s2 = 「abc」;
System.out.println(s1 == s2);
A:true,均指向常量池中對象。
Q:下列程序的輸出結果:
String s1 = new String(「abc」);
String s2 = new String(「abc」);
System.out.println(s1 == s2);
A:false,兩個引用指向堆中的不一樣對象。
Q:下列程序的輸出結果:
String s1 = 「abc」;
String s2 = 「a」;
String s3 = 「bc」;
String s4 = s2 + s3;
System.out.println(s1 == s4);
A:false,由於s2+s3其實是使用StringBuilder.append來完成,會生成不一樣的對象。
Q:下列程序的輸出結果:
String s1 = 「abc」;
final String s2 = 「a」;
final String s3 = 「bc」;
String s4 = s2 + s3;
System.out.println(s1 == s4);
A:true,由於final變量在編譯後會直接替換成對應的值,因此實際上等於s4=」a」+」bc」,而這種狀況下,編譯器會直接合併爲s4=」abc」,因此最終s1==s4。
Q:下列程序的輸出結果:
String s = new String(「abc」);
String s1 = 「abc」;
String s2 = new String(「abc」);
System.out.println(s == s1.intern());
System.out.println(s == s2.intern());
System.out.println(s1 == s2.intern());
A:false,false,true。
---------------------
做者:唐大麥
來源:CSDN
原文:https://blog.csdn.net/soonfly/article/details/70147205
版權聲明:本文爲博主原創文章,轉載請附上博文連接!
// 1. intern以後常量池中才有+以後的對象的引用 String str2 = new String("str") + new String("01"); // 常量池 str 01 // 堆 str 01 str01 str2.intern(); // 建立常量池中 指向堆中str01的引用 String str1 = "str01"; // 返回常量池中str01的引用 System.out.println(str2 == str1); //true // 2. new String時常量池中已經有對象 s1 = new String("testintern"); //常量池中 testintern 堆中 testintern s2 = s1.intern(); // 常量池中已經有testintern,直接返回 System.out.println(s1 == s2); // false 因此不是一個
String s1 = new String("aaa");
String s2 = "aaa";
System.out.println(s1 == s2); // false
s1 = new String("bbb").intern();
s2 = "bbb";
System.out.println(s1 == s2); // true
s1 = "ccc";
s2 = "ccc";
System.out.println(s1 == s2); // true
s1 = new String("ddd").intern();
s2 = new String("ddd").intern();
System.out.println(s1 == s2); // true
s1 = "ab" + "cd";
s2 = "abcd";
System.out.println(s1 == s2); // true
String temp = "hh";
s1 = "a" + temp;
// 若是調用s1.intern 則最終返回true
s2 = "ahh";
System.out.println(s1 == s2); // false
temp = "hh".intern();
s1 = "a" + temp;
s2 = "ahh";
System.out.println(s1 == s2); // false
temp = "hh".intern();
s1 = ("a" + temp).intern();
s2 = "ahh";
System.out.println(s1 == s2); // true
s1 = new String("1"); // 同時會生成堆中的對象 以及常量池中1的對象,可是此時s1是指向堆中的對象的
s1.intern(); // 常量池中的已經存在
s2 = "1";
System.out.println(s1 == s2); // false
String s3 = new String("1") + new String("1"); // 此時生成了四個對象 常量池中的"1" +
// 2個堆中的"1" +
// s3指向的堆中的對象(注此時常量池不會生成"11")
s3.intern(); // jdk1.7以後,常量池不單單能夠存儲對象,還能夠存儲對象的引用,會直接將s3的地址存儲在常量池
String s4 = "11"; // jdk1.7以後,常量池中的地址其實就是s3的地址
System.out.println(s3 == s4); // jdk1.7以前false, jdk1.7以後true
String s5 = new String("11");
String s6 = new String("11").intern();
System.out.println(s3 == s5);// false new對象是在堆中新建對象
System.out.println(s3 == s6);// true intern是在常量池中查找
s3 = new String("2") + new String("2");
s4 = "22"; // 常量池中不存在22,因此會新開闢一個存儲22對象的常量池地址
s3.intern(); // 常量池22的地址和s3的地址不一樣
System.out.println(s3 == s4); // false
// 對於何時會在常量池存儲字符串對象,我想咱們能夠基本得出結論: 1. 顯示調用String的intern方法的時候; 2. // 直接聲明字符串字面常量的時候,例如: String a = "aaa"; // 3. 字符串直接常量相加的時候,例如: String c = "aa" + "bb"; // 其中的aa/bb只要有任何一個不是字符串字面常量形式,都不會在常量池生成"aabb". 且此時jvm作了優化,不// // 會同時生成"aa"和"bb"在字符串常量池中