2016年06月27日 15:47:59 V核桃V 閱讀數：2794更多

在class檔案中，“常量池”是最複雜也最值得關注的內容。

　　Java是一種動態連線的語言，常量池的作用非常重要，常量池中除了包含程式碼中所定義的各種基本型別（如int、long等等）和物件型（如String及陣列）的常量值還，還包含一些以文字形式出現的符號引用，比如：

　　類和介面的全限定名；

　　欄位的名稱和描述符；

　　方法和名稱和描述符。

　　在C語言中，如果一個程式要呼叫其它庫中的函式，在連線時，該函式在庫中的位置（即相對於庫檔案開頭的偏移量）會被寫在程式中，在執行時，直接去這個地址呼叫函式；

　　而在Java語言中不是這樣，一切都是動態的。編譯時，如果發現對其它類方法的呼叫或者對其它類欄位的引用的話，記錄進class檔案中的，只能是一個文字形式的符號引用，在連線過程中，虛擬機器根據這個文字資訊去查詢對應的方法或欄位。

　　所以，與Java語言中的所謂“常量”不同，class檔案中的“常量”內容很非富，這些常量集中在class中的一個區域存放，一個緊接著一個，這裡就稱為“常量池”。

java中的常量池技術，是為了方便快捷地建立某些物件而出現的，當需要一個物件時，就可以從池中取一個出來（如果池中沒有則建立一個），則在需要重複重複建立相等變數時節省了很多時間。常量池其實也就是一個記憶體空間，不同於使用new關鍵字建立的物件所在的堆空間。本文只從java使用者的角度來探討java常量池技術，並不涉及常量池的原理及實現方法。個人認為，如果是真的專注java,就必須對這些細節方面有一定的瞭解。但知道它的原理和具體的實現方法則不是必須的。

常量池中物件和堆中的物件

1. public class Test{  
2. Integer i1=new Integer(1);  
3.    Integer i2=new Integer(1);  
4. //i1,i2分別位於堆中不同的記憶體空間  
5.    System.out.println(i1==i2);//輸出false  
6.    Integer i3=1;  
7.    Integer i4=1;  
8. //i3,i4指向常量池中同一個記憶體空間  
9.    System.out.println(i3==i4);//輸出true  
10. //很顯然，i1,i3位於不同的記憶體空間  
11. System.out.println(i1==i3);//輸出false  
12. }  

8種基本型別的包裝類和物件池

java中基本型別的包裝類的大部分都實現了常量池技術，這些類是Byte,Short,Integer,Long,Character,Boolean,另外兩種浮點數型別的包裝類則沒有實現。另外Byte,Short,Integer,Long,Character這5種整型的包裝類也只是在對應值小於等於127時才可使用物件池，也即物件不負責建立和管理大於127的這些類的物件。以下是一些對應的測試程式碼：

1. public class Test{  
2. public static void main(String[] args){  
3.    //5種整形的包裝類Byte,Short,Integer,Long,Character的物件，  
4.    //在值小於127時可以使用常量池  
5.    Integer i1=127;  
6.    Integer i2=127;  
7.    System.out.println(i1==i2)//輸出true  
8.    //值大於127時，不會從常量池中取物件  
9.    Integer i3=128;  
10.    Integer i4=128;  
11.    System.out.println(i3==i4)//輸出false  
12.    //Boolean類也實現了常量池技術  
13.    Boolean bool1=true;  
14.    Boolean bool2=true;  
15.    System.out.println(bool1==bool2);//輸出true  
16.    //浮點型別的包裝類沒有實現常量池技術  
17.    Double d1=1.0;  
18.    Double d2=1.0;  
19.    System.out.println(d1==d2)//輸出false  
20. }  
21. }  

String也實現了常量池技術

String類也是java中用得多的類，同樣為了建立String物件的方便，也實現了常量池的技術,測試程式碼如下:

1. public class Test{  
2. public static void main(String[] args){  
3. //s1,s2分別位於堆中不同空間  
4. String s1=new String("hello");  
5. String s2=new String("hello");  
6. System.out.println(s1==s2)//輸出false  
7. //s3,s4位於池中同一空間  
8. String s3="hello";  
9. String s4="hello";  
10. System.out.println(s3==s4);//輸出true  
11. }  
12. }  

最後

細節決定成敗，寫程式碼更是如此。

在JDK5.0之前是不允許直接將基本資料型別的資料直接賦值給其對應地包裝類的，如：Integer i = 5; 

但是在JDK5.0中支援這種寫法，因為編譯器會自動將上面的程式碼轉換成如下程式碼：Integer i=Integer.valueOf(5);  

這就是Java的裝箱.JDK5.0也提供了自動拆箱. Integer i =5;  int j = i;  

Integer的封裝：

1. public static Integer valueOf(int i) {    
2.     final int offset = 128;    
3.     if (i >= -128 && i <= 127) { // must cache     
4.         return IntegerCache.cache[i + offset];    
5.     }    
6.       return new Integer(i);    
7.  }    
8. private static class IntegerCache {    
9. private IntegerCache(){}    
10. static final Integer cache[] = new Integer[-(-128) + 127 + 1];    
11.     static {    
12.         for(int i = 0; i < cache.length; i++)    
13.         cache[i] = new Integer(i - 128);    
14.     }    
15. }    

由於cache[]在IntegerCache類中是靜態陣列，也就是隻需要初始化一次，即static｛......｝部分，所以，如果Integer物件初始化時是-128~127的範圍，就不需要再重新定義申請空間，都是同一個物件---在IntegerCache.cache中，這樣可以在一定程度上提高效率。