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。

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)建新的對象。

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);
  }

Integer i1 = 400;
Integer i2 = 400;
 
System.out.println(i1==i2);//false

2.兩種浮點數(shù)類型的包裝類Float、Double并沒有實現(xiàn)常量池技術

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)建新的對象

Integer i1 = 40;
Integer i2 = new Integer(40);
 
System.out.println(i1 == i2);//false

這種情況new Integer 不會執(zhí)行自動裝箱引用常量池中的已有常量，而是會直接在堆中生成一個新對象。

4.Integer詳解

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));

i1=i2  true
i1=i2+i3  true
i1=i4  false
i4=i5  false
i4=i5+i6  true
40=i5+i6  true
i7=i8  false

解釋：語句i4==i5+i6，因為+這個操作符不適用于Integer對象，首先i5和i6進行自動拆箱操作，進行數(shù)值相加，即i4==40。然后Integer對象無法與數(shù)值進行直接比較，所以i4自動拆箱轉為int值40，最終這條語句轉為40==40進行數(shù)值比較。

String類和常量池

1.String對象創(chuàng)建方式

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)生的新對象并不會加入字符串常量池中。

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

public static final String A = "ab"; // 常量A
public static final String B = "cd"; // 常量B
public 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”;

public static final String A; // 常量A
public static final String B;  // 常量B
static {  
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）類加載對一個類只會進行一次?！眡yz”在類加載時就已經(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相等的字符串,如果有則返回該字符串的引用,如果沒有則添加自己的字符串進入常量池。

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));
}

s1 == s2? false
s3 == s2? true

總結

以上就是本文關于深入探索Java常量池的全部內(nèi)容，希望對大家有所幫助。感興趣的朋友可以繼續(xù)參閱本站其他相關專題，如有不足之處，歡迎留言指出。

最新評論