java的常量池通常分為兩種：靜態(tài)常量池和運行時常量池
靜態(tài)常量池：class文件中的常量池，class文件中的常量池包括了字符串(數(shù)字)字面值，類和方法的信息，占用了class文件的大部分空間。
運行時常量池：jvm在完成加載類之后將class文件中常量池載入到內(nèi)存中，并保存在方法區(qū)中。平時我們所講的常量池就是指方法區(qū)中的運行時常量池。其相對于class文件常量池的另外一個重要特征是具備動態(tài)性，java語言并不要求常量一定只有編譯期才能產(chǎn)生，也就是并非預置入class文件中常量池的內(nèi)容才能進入方法區(qū)運行時常量池，運行期間也可能將新的常量放入池中，這種特性被開發(fā)人員利用比較多的就是string類的intern()方法。
程序計數(shù)器：是程序執(zhí)行的流水線，指示下一條該執(zhí)行哪條命令。
本地方法棧：jvm調(diào)用操作系統(tǒng)方法使用的棧。
虛擬機棧：jvm執(zhí)行java代碼所使用的棧
虛擬機堆：存放對象的地方，在java程序中new出來的對象都存放在堆中。
方法區(qū)：存放了常量、類信息、靜態(tài)變量，可以理解為class文件在內(nèi)存中存放的位置。
常量池的好處：
常量池是為了避免頻繁的創(chuàng)建和銷毀對象而影響系統(tǒng)性能，其實現(xiàn)了對象的共享。
例如字符串常量池，在編譯階段就把所有的字符串文字放到一個常量池中。
1.節(jié)省內(nèi)存空間：常量池中的所有字面值相同的字符串常量合并，只占用一個空間
2.節(jié)省運行時間：在進行字符串比較時，==比equals()要快。對于兩個引用變量，只用==判斷引用是否相等，也就可以判斷實際值是否相等。
==對于基本數(shù)據(jù)類型和對象代表的含義是不同的。
對于基本數(shù)據(jù)類型：==比較的是基本數(shù)據(jù)類型的數(shù)值對于對象：==比較的是對象在內(nèi)存中的內(nèi)存地址
8種基本數(shù)據(jù)類型的包裝類和常量池
java中基本數(shù)據(jù)類型的包裝類大部分都實現(xiàn)了常量池技術，即byte，short，integer，long，character，boolean。
|
1
2
3
4
|
integer i1 = 40;integer i2 = 40; system.out.println(i1==i2);//true |
byte，short，integer，long，character這5種包裝類默認創(chuàng)建了[-128,127]的對應類型的緩存數(shù)據(jù)存放到常量池中，超過此范圍仍然會創(chuàng)建新的對象。
|
1
2
3
4
5
6
|
public static integer valueof(int i) { assert integercache.high >= 127; if (i >= integercache.low && i <= integercache.high) return integercache.cache[i + (-integercache.low)]; return new integer(i); } |
|
1
2
3
4
|
integer i1 = 400;integer i2 = 400; system.out.println(i1==i2);//false |
2.兩種浮點數(shù)類型的包裝類float、double并沒有實現(xiàn)常量池技術
|
1
2
3
4
|
double d1 = 2.5;double d2 = 2.5; system.out.println(d1==d2);//false |
3.應用常量池的場景
（1）.integeri1=40;因為integer是基本數(shù)據(jù)類型int的包裝類，是一個對象，所以java在編譯的時候會執(zhí)行自動裝箱操作直接將代碼封裝成integeri1=integer.valueof(40)，從而使用常量池中的對象
（2）.integeri1=newinteger(40);這種情況下會創(chuàng)建新的對象
|
1
2
3
4
|
integer i1 = 40;integer i2 = new integer(40); system.out.println(i1 == i2);//false |
這種情況new integer 不會執(zhí)行自動裝箱引用常量池中的已有常量，而是會直接在堆中生成一個新對象。
4.integer詳解
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
integer i1 = 40; integer i2 = 40; integer i3 = 0; integer i4 = new integer(40); integer i5 = new integer(40); integer i6 = new integer(0); integer i7 = 128; integer i8 = 128; system.out.println("i1=i2 " + (i1 == i2)); system.out.println("i1=i2+i3 " + (i1 == i2 + i3)); system.out.println("i1=i4 " + (i1 == i4)); system.out.println("i4=i5 " + (i4 == i5)); system.out.println("i4=i5+i6 " + (i4 == i5 + i6)); system.out.println("40=i5+i6 " + (40 == i5 + i6)); system.out.println("i7=i8 " + (i7 == i8)); |
|
1
2
3
4
5
6
7
|
i1=i2 truei1=i2+i3 truei1=i4 falsei4=i5 falsei4=i5+i6 true40=i5+i6 truei7=i8 false |
解釋：語句i4==i5+i6，因為+這個操作符不適用于integer對象，首先i5和i6進行自動拆箱操作，進行數(shù)值相加，即i4==40。然后integer對象無法與數(shù)值進行直接比較，所以i4自動拆箱轉為int值40，最終這條語句轉為40==40進行數(shù)值比較。
string類和常量池
1.string對象創(chuàng)建方式
|
1
2
3
|
string s1 = "abdcd";string s2 = new string("abcd");system.out.println(s1==s2);//false |
這兩種不同的創(chuàng)建方式是有差別的，第一種是在常量池中拿對象，第二種是在堆內(nèi)存空間中創(chuàng)建新的對象。
只要使用new就會在堆中創(chuàng)建新對象。
2.連接表達式+
(1).只有使用“”包含文本的方式創(chuàng)建的string對象之間采用“+”連接產(chǎn)生的新對象才會被加入字符串常量池中。
(2).對于其他形式比如兩個對象引用直接通過“+”連接或者通過new方式創(chuàng)建的對象連接，所產(chǎn)生的新對象并不會加入字符串常量池中。
|
1
2
3
4
5
6
7
8
9
|
string str1 = "str";string str2 = "ing"; string str3 = "str" + "ing";string str4 = str1 + str2;system.out.println(str3 == str4);//false string str5 = "string";system.out.println(str3 == str5);//true |
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public static final string a = "ab"; // 常量apublic static final string b = "cd"; // 常量bpublic static void main(string[] args) {string s = a + b; // 將兩個常量用+連接對s進行初始化 string t = "abcd"; if (s == t) { system.out.println("s等于t，它們是同一個對象"); } else { system.out.println("s不等于t，它們不是同一個對象"); } } s等于t，它們是同一個對象 |
a和b都是常量，值是固定的，因此s的值也是固定的，它在類被編譯時就已經(jīng)確定了。也就是說：string s=a+b; 等同于：string s=”ab”+”cd”;
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public static final string a; // 常量apublic static final string b; // 常量bstatic { a = "ab"; b = "cd"; } public static void main(string[] args) { // 將兩個常量用+連接對s進行初始化 string s = a + b; string t = "abcd"; if (s == t) { system.out.println("s等于t，它們是同一個對象"); } else { system.out.println("s不等于t，它們不是同一個對象"); } } s不等于t，它們不是同一個對象 |
a和b雖然被定義為常量，但是它們都沒有馬上被賦值。在運算出s的值之前，他們何時被賦值，以及被賦予什么樣的值，都是個變數(shù)。因此a和b在被賦值之前，性質(zhì)類似于一個變量。那么s就不能在編譯期被確定，而只能在運行時被創(chuàng)建了。
3.strings1=newstring(“xyz”);創(chuàng)建了幾個對象？
考慮類加載階段和實際執(zhí)行時。
（1）類加載對一個類只會進行一次。”xyz”在類加載時就已經(jīng)創(chuàng)建并駐留了（如果該類被加載之前已經(jīng)有”xyz”字符串被駐留過則不需要重復創(chuàng)建用于駐留的”xyz”實例）。駐留的字符串是放在全局共享的字符串常量池中的。
（2）在這段代碼后續(xù)被運行的時候，”xyz”字面量對應的string實例已經(jīng)固定了，不會再被重復創(chuàng)建。所以這段代碼將常量池中的對象復制一份放到heap中，并且把heap中的這個對象的引用交給s1持有。
這條語句創(chuàng)建了2個對象。
4.java.lang.string.intern()
運行時常量池相對于class文件常量池的另外一個重要特征是具備動態(tài)性，java語言并不要求常量一定只有編譯期才能產(chǎn)生，也就是并非預置入class文件中常量池的內(nèi)容才能進入方法區(qū)運行時常量池，運行期間也可能將新的常量放入池中，這種特性被開發(fā)人員利用比較多的就是string類的intern()方法。
string的intern()方法會查找在常量池中是否存在一份equal相等的字符串,如果有則返回該字符串的引用,如果沒有則添加自己的字符串進入常量池。
|
1
2
3
4
5
6
7
|
public static void main(string[] args) { string s1 = new string("計算機"); string s2 = s1.intern(); string s3 = "計算機"; system.out.println("s1 == s2? " + (s1 == s2)); system.out.println("s3 == s2? " + (s3 == s2));} |
|
1
2
|
s1 == s2? falses3 == s2? true |
總結
以上就是本文關于深入探索java常量池的全部內(nèi)容，希望對大家有所幫助。感興趣的朋友可以繼續(xù)參閱本站其他相關專題，如有不足之處，歡迎留言指出。
原文鏈接：https://www.2cto.com/kf/201608/540440.html
