名詞解釋
Java是一種動態連結的語言，常量池的作用非常重要，常量池中除了包含代碼中所定義的各種基本類型（如int、long等等）和對象型（如String及數組）的常量值外，還包含一些以文本形式出現的符號引用，比如：
類和接口的全限定名；
欄位的名稱和描述符；
方法的名稱和描述符。
在C語言中，如果一個程式要調用其它庫中的函式，在連結時，該函式在庫中的位置（即相對於庫檔案開頭的偏移量）會被寫在程式中，在運行時，直接去這個地址調用函式；
而在Java語言中不是這樣，一切都是動態的。編譯時，如果發現對其它類方法的調用或者對其它類欄位的引用的語句，記錄進class檔案中的只能是一個文本形式的符號引用，在連線過程中，虛擬機根據這個文本信息去查找對應的方法或欄位。
所以，與Java語言中的所謂“常量”不同，class檔案中的“常量”內容很豐富，這些常量集中在class中的一個區域存放，一個緊接著一個，這裡就稱為“常量池”。
具體結構
在Java程式中，有很多的東西是永恆的，不會在運行過程中變化。比如一個類的名字，一個類欄位的名字/所屬類型，一個類方法的名字/返回類型/參數名與所屬類型，一個常量，還有在程式中出現的大量的字面值。
比如下面小段源碼中粗體代碼顯示的部分：
public class ClassTest {
private String itemS ="我們 ";
private final int itemI =100 ;
public void setItemS (String para ){...}
}
而這些在JVM解釋執行程式的時候是非常重要的。那么編譯器將源程式編譯成class檔案後，會用一部分位元組分類存儲這些粗體代碼。而這些位元組我們就稱為常量池。事實上，只有JVM載入class後，在方法區中為它們開闢了空間才更像一個“池”。
正如上面所示，一個程式中有很多永恆的類似粗體代碼顯示的部分。每一個都是常量池中的一個常量表(常量項)。而這些常量表之間又有不同，class檔案共有11種常量表，如下所示：
| 常量表類型 | 標誌值(占1 byte) | 描述 |
| CONSTANT_Utf8 | 1 | UTF-8編碼的Unicode字元串 |
| CONSTANT_Integer | 3 | int類型的字面值 |
| CONSTANT_Float | 4 | float類型的字面值 |
| CONSTANT_Long | 5 | long類型的字面值 |
| CONSTANT_Double | 6 | double類型的字面值 |
| CONSTANT_Class | 7 | 對一個類或接口的符號引用 |
| CONSTANT_String | 8 | String類型字面值的引用 |
| CONSTANT_Fieldref | 9 | 對一個欄位的符號引用 |
| CONSTANT_Methodref | 10 | 對一個類中方法的符號引用 |
| CONSTANT_InterfaceMethodref | 11 | 對一個接口中方法的符號引用 |
| CONSTANT_NameAndType | 12 | 對一個欄位或方法的部分符號引用 |
(1) CONSTANT_Utf8 用UTF-8編碼方式來表示程式中所有的重要常量字元串。這些字元串包括： ①類或接口的全限定名， ②超類的全限定名，③父接口的全限定名， ④類欄位名和所屬類型名，⑤類方法名和返回類型名、以及參數名和所屬類型名。⑥字元串字面值
表格式： tag(標誌1：占1byte) length(字元串所占位元組的長度，占2byte) bytes(字元串位元組序列)
(2) CONSTANT_Integer、 CONSTANT_Float、 CONSTANT_Long、 CONSTANT_Double 所有基本數據類型的字面值。比如在程式中出現的1用CONSTANT_Integer表示。3.1415926F用 CONSTANT_Float表示。
表格式： tag bytes(基本數據類型所需使用的位元組序列)
(3) CONSTANT_Class 使用符號引用來表示類或接口。我們知道所有類名都以 CONSTANT_Utf8表的形式存儲。但是我們並不知道 CONSTANT_Utf8表中哪些字元串是類名，那些是方法名。因此我們必須用一個指向類名字元串的符號引用常量來表明。
表格式： tag name_index(給出表示類或接口名的CONSTANT_Utf8表的索引)
(4) CONSTANT_String 同 CONSTANT_Class，指向包含字元串字面值的 CONSTANT_Utf8表。
表格式： tag string_index(給出表示字元串字面值的CONSTANT_Utf8表的索引)
(5) CONSTANT_Fieldref 、 CONSTANT_Methodref、 CONSTANT_InterfaceMethodref 指向包含該欄位或方法所屬類名的 CONSTANT_Utf8表，以及指向包含該欄位或方法的名字和描述符的 CONSTANT_NameAndType 表
表格式： tag class _index(給出包含所屬類名的CONSTANT_Utf8表的索引) name_and_type_index(包含欄位名或方法名以及描述符的 CONSTANT_NameAndType表 的索引)
(6) CONSTANT_NameAndType 指向包含欄位名或方法名以及描述符的 CONSTANT_Utf8表。
表格式： tag name_index(給出表示欄位名或方法名的CONSTANT_Utf8表的索引) type_index(給出表示描述符的CONSTANT_Utf8表的索引)
在Java原始碼中的每一個字面值字元串，都會在編譯成class檔案階段，形成標誌號為8(CONSTANT_String_info)的常量表 。 當JVM載入 class檔案的時候，會為對應的常量池建立一個記憶體數據結構，並存放在方法區中。同時JVM會自動為CONSTANT_String_info常量表中的字元串常量的字面值 在堆中創建新的String對象(intern字元串對象 ，又叫拘留字元串對象)。然後把CONSTANT_String_info常量表的入口地址轉變成這個堆中String對象的直接地址(常量池解析)。
拘留字元串對象
原始碼中所有相同字面值的字元串常量只可能建立唯一 一個拘留字元串對象。 實際上JVM是通過一個記錄了拘留字元串引用的內部數據結構來維持這一特性的。在Java程式中，可以調用String的intern()方法來使得一個常規字元串對象成為拘留字元串對象。
(1)String s=new String("Hello world"); 編譯成class檔案後的指令(在myeclipse中查看):
事實上，在運行這段指令之前，JVM就已經為"Hello world"在堆中創建了一個拘留字元串( 值得注意的是：如果源程式中還有一個"Hello world"字元串常量，那么他們都對應了同一個堆中的拘留字元串)。然後用這個拘留字元串的值來初始化堆中用new指令創建出來的新的String對象，局部變數s實際上存儲的是new出來的堆對象地址。
(2)String s="Hello world";
這跟(1)中創建指令有很大的不同，此時局部變數s存儲的是早已創建好的拘留字元串的堆地址。
java常量池技術 java中的常量池技術，是為了方便快捷地創建某些對象而出現的，當需要一個對象時，就可以從池中取一個出來（如果池中沒有則創建一個），則在需要重複創建相等變數時節省了很多時間。常量池其實也就是一個記憶體空間，常量池存在於方法區中。
String類也是java中用得多的類，同樣為了創建String對象的方便，也實現了常量池的技術。
測試代碼如下 :
public class Test{
public static void main(String[] args){
//s1,s2分別位於棧中，指向堆中不同的空間
String s1=new String("hello");
String s2=new String("hello");
System.out.println(s1==s2);//輸出false
//s3,s4位於池中同一空間
String s3="hello" String s4="hello";
System.out.println(s3==s4);//輸出true
}
}
用new String（）創建的字元串不是常量，不能在編譯期就確定，所以new String（）創建的字元串不放入常量池中，他們有自己的地址空間。
String 對象（記憶體）的不變性機制會使修改String字元串時，產生大量的對象，因為每次改變字元串，都會生成一個新的String。 java 為了更有效的使用記憶體，常量池在編譯期遇見String 字元串時，它會檢查該池內是否已經存在相同的String 字元串，如果找到，就把新變數的引用指向現有的字元串對象，不創建任何新的String 常量對象，沒找到再創建新的。所以對一個字元串對象的任何修改，都會產生一個新的字元串對象，原來的依然存在，等待垃圾回收。
代碼：
String a = “test”;
String b = “test”;
String b = b+"java";
a，b同時指向常量池中的常量值"test"，b=b+"java"之後，b原先指向一個常量，內容為"test”，通過對b進行+"java" 操作後，b之前所指向的那個值沒有改變，但此時b不指向原來那個變數值了，而指向了另一個String變數，內容為”test java“。原來那個變數還存在於記憶體之中，只是b這個變數不再指向它了。
八種基本類型的包裝類和對象池 java中基本類型的包裝類的大部分都實現了常量池技術，這些類是Byte,Short,Integer,Long,Character,Boolean,另外兩種浮點數類型的包裝類則沒有實現。另外Byte,Short,Integer,Long,Character這5種整型的包裝類也只是在對應值小於等於127時才可使用常量池，也即對象不負責創建和管理大於127的這些類的對象。 一些對應的測試代碼：
public class Test{ public static void main(String[] args){
//5種整形的包裝類Byte,Short,Integer,Long,Character的對象，
//在值小於127時可以使用常量池
Integer i1=127;
Integer i2=127;
System.out.println(i1==i2); //輸出true
//值大於127時，不會從常量池中取對象
Integer i3=128;
Integer i4=128;
System.out.println(i3==i4); //輸出false
//Boolean類也實現了常量池技術
Boolean bool1=true;
Boolean bool2=true;
System.out.println(bool1==bool2); //輸出true
//浮點類型的包裝類沒有實現常量池技術
Double d1=1.0;
Double d2=1.0;
System.out.println(d1==d2); //輸出false
}
}
對Integer對象的代碼補充
public static Integer valueOf(int i) {
final int offset = 128;
if (i >= -128 && i <= 127) {
return IntegerCache.cache[i + offset];
}
return new Integer(i);
}
當你直接給一個Integer對象一個int值的時候，其實它調用了valueOf方法，然後你賦的這個值很特別，是128，那么沒有進行cache方法，相當於new了兩個新對象。所以問題中定義a、b的兩句代碼就類似於：
Integer a = new Integer(128);
Integer b = new Integer(128);
這個時候再問你，輸出結果是什麼？你就知道是false了。如果把這個數換成127，再執行：
Integer a = 127;
Integer b = 127;
System.out.println(a == b);
結果就是：true
進行對象比較時最好還是使用equals，便於按照自己的目的進行控制。這裡引出equals()和==，equals比較的是字元串字面值即比較內容，==比較引用。
看一下IntegerCache這個類裡面的內容 ：
private static class IntegerCache {
private IntegerCache() {
}
static final Integer cache[] = new Integer[-(-128) + 127 + 1];
static {
for (int i = 0; i < cache.length; i++)
cache[i] = new Integer(i - 128);
}
}
由於cache[]在IntegerCache類中是靜態數組，也就是只需要初始化一次，即static{......}部分，所以，如果Integer對象初始化時是-128~127的範圍，就不需要再重新定義申請空間，都是同一個對象---在IntegerCache.cache中，這樣可以在一定程度上提高效率。
針對String方面的補充
在同包同類下,引用自同一String對象.
在同包不同類下,引用自同一String對象.
在不同包不同類下,依然引用自同一String對象.
在編譯成.class時能夠識別為同一字元串的,自動最佳化成常量,所以也引用自同一String對象.
在運行時創建的字元串具有獨立的記憶體地址,所以不引用自同一String對象.
String的intern()方法會查找在常量池中是否存在一份equal相等的字元串,
如果有則返回一個引用,沒有則添加自己的字元串進入常量池，注意：只是字元串部分。
所以這時會存在2份拷貝，常量池的部分被String類私有並管理，自己的那份按對象生命周期繼續使用。
返回字元串對象的規範化表示形式
一個初始值為空的字元串池，它由類 String 私有地維護。
當調用 intern 方法時，如果池已經包含一個等於此 String 對象的字元串（該對象由 equals(Object) 方法確定），則返回池中的字元串引用。否則，將此 String 對象添加到池中，並且返回此 String 對象的引用。
它遵循對於任何兩個字元串 s 和 t，若且唯若 s.equals(t) 為 true 時，s.intern() == t.intern() 才為 true。
所有字面值字元串和字元串賦值常量表達式都是內部的。
------------------------------------代碼演示補充-------------------------------------
String s0= "java";
String s1=new String("java");
String s2=new String("java");
s1.intern();
s2=s2.intern(); //把常量池中"java"的引用賦給s2
System.out.println( s0==s1);//false “ intern返回的引用沒有引用變數接收~ s1.intern();等於廢代碼.”
System.out.println( s0==s1.intern() );//true
System.out.println( s0==s2 );//true
------------------------------------代碼演示補充-------------------------------------
String s1=new String("java");
String s2=s1.intern();//s1 檢查常量池，發現沒有就拷貝自己的字元串進去
//s2 引用該字元串常量池的地址
System.out.println(s2 == s1);//false
System.out.println( s2==s1.intern());//true
System.out.println( s1==s1.intern());// false
