本文目錄一覽：
- 1、java中 關於常量池 棧內存 堆內存
- 2、Java 中的 常量共享池 什麼意思
- 3、常量池的具體結構
- 4、JAVA常量池中存儲的常量是什麼
- 5、Java中的幾種常量池
- 6、Java運行時常量池是什麼？
java中 關於常量池 棧內存 堆內存
Java中所有局部變量和對象的引用都是存儲在棧內存中的，int a = 1;它是局部變量肯定是在棧內存，但是它與常量池沒有關係；
常量池是堆內存中的一部分，專門用來存儲字符串常量；所以String a=”abc”中，引用a是存儲在棧內存的，指向常量池中的”abc”；
但是如果是String a = new String(“abc”);就又不一樣了，對於通過構造函數得到的”abc”字符串對象，引用a還是在棧內存，但是”abc”不會存到字符串常量池中，而是在常量池之外的其他堆內存中再生成一個”abc”，由於這個對象與原先常量池中的”abc”對象是equal關係，它們之間會建立起一種聯繫；
Java 中的 常量共享池 什麼意思
一直有個疑問，java中字符串池,String池,共享池是怎麼回事？
好像知道什麼意思，但具體又不太清楚，所以也一直沒太關注。
從網上看了些資料，解釋了下疑問。
在java的棧中，有共享池的概念，把一些常量會放到這個共享池中，包括字符串常量和基本類型常量。
共享的操作時在編譯時 由編譯器完成的，可以節省內存，並提高效率。
例如語句string str = “hello”, 首先在棧中創建字符串引用變量str， 再看看棧中有沒有“hello”，如果有就str直接指向它，沒有就創建“hello”並放在棧中，然後指向它。
對於int之類的基本類型的變量也差不多都是這樣的。
而對於 String str = new String(“hello”)，則是創建新的對象，並放在堆內存中。是在runtime的時候分配內存的。
這樣做效率和節省內存方面不如String str = “hello”， 但是更靈活，如果編譯時不知道要創建什麼樣的字符串，就
只能運行時創建了。
常量池的具體結構
在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
JAVA常量池中存儲的常量是什麼
我當初也存在這樣一個疑問，下面我把當初所搜集的一些資料以及自己的理解貼出來給你看看(比較多，需要耐心點看，呵呵)：
理解Java常量池
JVM運行時數據區的內存模型由五部分組成：
【1】方法區
【2】堆
【3】JAVA棧
【4】PC寄存器
【5】本地方法棧
對於String s = “haha” ,它的虛擬機指令：
0: ldc #16; //String haha
2: astore_1
3: return
對於上面虛擬機指令，其各自的指令流程在《深入JAVA虛擬機》這樣描述到(結合上面實例)：
ldc指令格式：ldc,index
ldc指令過程：
要執行ldc指令，JVM首先查找index所指定的常量池入口，在index指向的常量池入口，JVM將會查找CONSTANT_Integer_info，CONSTANT_Float_info和CONSTANT_String_info入口。如果還沒有這些入口，JVM會解析它們。而對於上面的hahaJVM會找到CONSTANT_String_info入口，同時，將把指向被拘留String對象（由解析該入口的進程產生）的引用壓入操作數棧。
astore_1指令格式：astore_1
astore_1指令過程：
要執行astore_1指令，JVM從操作數棧頂部彈出一個引用類型或者returnAddress類型值，然後將該值存入由索引1指定的局部變量中,即將引用類型或者returnAddress類型值存入局部變量1。
return 指令的過程：
從方法中返回，返回值為void。
談一下我個人理解：
從上面的ldc指令的執行過程可以得出：s的值是來自被拘留String對象（由解析該入口的進程產生）的引用，即可以理解為是從被拘留String對象的引用複製而來的，故我個人的理解是s的值是存在棧當中。上面是對於s值得分析，接着是對於”haha”值的分析,我們知道，對於String s = “haha” 其中”haha”值在JAVA程序編譯期就確定下來了的。簡單一點說，就是haha的值在程序編譯成class文件後，就在class文件中生成了（大家可以用UE編輯器或其它文本編輯工具在打開class文件後的字節碼文件中看到這個haha值）。執行JAVA程序的過程中，第一步是class文件生成，然後被JVM裝載到內存執行。那麼JVM裝載這個class到內存中，其中的haha這個值，在內存中是怎麼為其開闢空間並存儲在哪個區域中呢？
說到這裡，我們不妨先來了解一下JVM常量池這個結構，《深入JAVA虛擬機》書中有這樣的描述：
常量池
虛擬機必須為每個被裝載的類型維護一個常量池。常量池就是該類型所用到常量的一個有序集和，包括直接常量（string,integer和floating point常量）和對其他類型，字段和方法的符號引用。對於String常量，它的值是在常量池中的。而JVM中的常量池在內存當中是以表的形式存在的，對於String類型，有一張固定長度的CONSTANT_String_info表用來存儲文字字符串值，注意：該表只存儲文字字符串值，不存儲符號引用。說到這裡，對常量池中的字符串值的存儲位置應該有一個比較明了的理解了。
在介紹完JVM常量池的概念後，接着談開始提到的”haha”的值的內存分布的位置。對於haha的值，實際上是在class文件被JVM裝載到內存當中並被引擎在解析ldc指令並執行ldc指令之前，JVM就已經為haha這個字符串在常量池的CONSTANT_String_info表中分配了空間來存儲haha這個值。既然haha這個字符串常量存儲在常量池中，根據《深入JAVA虛擬機》書中描述：常量池是屬於類型信息的一部分，類型信息也就是每一個被轉載的類型，這個類型反映到JVM內存模型中是對應存在於JVM內存模型的方法區中，也就是這個類型信息中的常量池概念是存在於在方法區中，而方法區是在JVM內存模型中的堆中由JVM來分配的。所以，haha的值是應該是存在堆空間中的。
而對於String s = new String(“haha”) ,它的JVM指令：
0: new #16; //class String
3: dup
4: ldc #18; //String haha
6: invokespecial #20; //Method java/lang/String.””:(Ljava/lang/String;)V
9: astore_1
10: return
對於上面虛擬機指令，其各自的指令流程在《深入JAVA虛擬機》這樣描述到(結合上面實例)：
new指令格式：new indexbyte1,indexbyte2
new指令過程：
要執行new指令，Jvm通過計算(indextype18)|indextype2生成一個指向常量池的無符號16位索引。然後JVM根據計算出的索引查找常量池入口。該索引所指向的常量池入口必須為CONSTANT_Class_info。如果該入口尚不存在，那麼JVM將解析這個常量池入口，該入口類型必須是類。JVM從堆中為新對象映像分配足夠大的空間，並將對象的實例變量設為默認值。最後JVM將指向新對象的引用objectref壓入操作數棧。
dup指令格式：dup
dup指令過程：
要執行dup指令，JVM複製了操作數棧頂部一個字長的內容，然後再將複製內容壓入棧。本指令能夠從操作數棧頂部複製任何單位字長的值。但絕對不要使用它來複制操作數棧頂部任何兩個字長(long型或double型)中的一個字長。上面例中，即複製引用objectref，這時在操作數棧存在2個引用。
ldc指令格式：ldc,index
ldc指令過程：
要執行ldc指令，JVM首先查找index所指定的常量池入口，在index指向的常量池入口，JVM將會查找CONSTANT_Integer_info，CONSTANT_Float_info和CONSTANT_String_info入口。如果還沒有這些入口，JVM會解析它們。而對於上面的haha,JVM會找到CONSTANT_String_info入口，同時，將把指向被拘留String對象（由解析該入口的進程產生）的引用壓入操作數棧。
invokespecial指令格式：invokespecial,indextype1,indextype2
invokespecial指令過程：對於該類而言，該指令是用來進行實例初始化方法的調用。鑒於該指令篇幅，具體可以查閱《深入JAVA虛擬機》中描述。上面例子中，即通過其中一個引用調用String類的構造器，初始化對象實例，讓另一個相同的引用指向這個被初始化的對象實例，然後前一個引用彈出操作數棧。
astore_1指令格式：astore_1
astore_1指令過程：
要執行astore_1指令，JVM從操作數棧頂部彈出一個引用類型或者returnAddress類型值，然後將該值存入由索引1指定的局部變量中,即將引用類型或者returnAddress類型值存入局部變量1。
return 指令的過程:
從方法中返回，返回值為void。
要執行astore_1指令，JVM從操作數棧頂部彈出一個引用類型或者returnAddress類型值，然後將該值存入由索引1指定的局部變量中,即將引用類型或者returnAddress類型值存入局部變量1。
通過上面6個指令，可以看出，String s = new String(“haha”);中的haha存儲在堆空間中，而s則是在操作數棧中。
上面是對s和haha值的內存情況的分析和理解；那對於String s = new String(“haha”);語句,到底創建了幾個對象呢?
我的理解：這裡”haha”本身就是常量池中的一個對象，而在運行時執行new String()時，將常量池中的對象複製一份放到堆中，並且把堆中的這個對象的引用交給s持有。所以這條語句就創建了2個String對象。
下面是一些String相關的常見問題：
String中的final用法和理解
final StringBuffer a = new StringBuffer(“111”);
final StringBuffer b = new StringBuffer(“222”);
a=b;//此句編譯不通過
final StringBuffer a = new StringBuffer(“111”);
a.append(“222”);//編譯通過
可見，final只對引用的”值”(即內存地址)有效，它迫使引用只能指向初始指向的那個對象，改變它的指向會導致編譯期錯誤。至於它所指向的對象的變化，final是不負責的。
String 常量池問題的幾個例子
下面是幾個常見例子的比較分析和理解：
[1]
String a = “a1”;
String b = “a” + 1;
System.out.println((a == b)); //result = true
String a = “atrue”;
String b = “a” + “true”;
System.out.println((a == b)); //result = true
String a = “a3.4”;
String b = “a” + 3.4;
System.out.println((a == b)); //result = true
分析：JVM對於字符串常量的”+”號連接，將程序編譯期，JVM就將常量字符串的”+”連接優化為連接後的值，拿”a” + 1來說，經編譯器優化後在class中就已經是a1。在編譯期其字符串常量的值就確定下來，故上面程序最終的結果都為true。
[2]
String a = “ab”;
String bb = “b”;
String b = “a” + bb;
System.out.println((a == b)); //result = false
分析：JVM對於字符串引用，由於在字符串的”+”連接中，有字符串引用存在，而引用的值在程序編譯期是無法確定的，即”a” + bb無法被編譯器優化，只有在程序運行期來動態分配並將連接後的新地址賦給b。所以上面程序的結果也就為false。
[3]
String a = “ab”;
final String bb = “b”;
String b = “a” + bb;
System.out.println((a == b)); //result = true
分析：和[3]中唯一不同的是bb字符串加了final修飾，對於final修飾的變量，它在編譯時被解析為常量值的一個本地拷貝存儲到自己的常量池中或嵌入到它的字節碼流中。所以此時的”a” + bb和”a” + “b”效果是一樣的。故上面程序的結果為true。
[4]
String a = “ab”;
final String bb = getBB();
String b = “a” + bb;
System.out.println((a == b)); //result = false
private static String getBB() {
return “b”;
}
分析：JVM對於字符串引用bb，它的值在編譯期無法確定，只有在程序運行期調用方法後，將方法的返回值和”a”來動態連接並分配地址為b，故上面程序的結果為false。
通過上面4個例子可以得出得知：
String s = “a” + “b” + “c”;
就等價於String s = “abc”;
String a = “a”;
String b = “b”;
String c = “c”;
String s = a + b + c;
這個就不一樣了，最終結果等於：
StringBuffer temp = new StringBuffer();
temp.append(a).append(b).append(c);
String s = temp.toString();
由上面的分析結果，可就不難推斷出String 採用連接運算符（+）效率低下原因分析，形如這樣的代碼：
public class Test {
public static void main(String args[]) {
String s = null;
for(int i = 0; i 100; i++) {
s += “a”;
}
}
}
每做一次 + 就產生個StringBuilder對象，然後append後就扔掉。下次循環再到達時重新產生個StringBuilder對象，然後 append 字符串，如此循環直至結束。 如果我們直接採用 StringBuilder 對象進行 append 的話，我們可以節省 N – 1 次創建和銷毀對象的時間。所以對於在循環中要進行字符串連接的應用，一般都是用StringBuffer或StringBulider對象來進行append操作。
String對象的intern方法理解和分析：
public class Test4 {
private static String a = “ab”;
public static void main(String[] args){
String s1 = “a”;
String s2 = “b”;
String s = s1 + s2;
System.out.println(s == a);//false
System.out.println(s.intern() == a);//true
}
}
這裡用到Java裡面是一個常量池的問題。對於s1+s2操作，其實是在堆裡面重新創建了一個新的對象,s保存的是這個新對象在堆空間的的內容，所以s與a的值是不相等的。而當調用s.intern()方法，卻可以返回s在常量池中的地址值，因為a的值存儲在常量池中，故s.intern和a的值相等
Java中的幾種常量池
字符串常量池：當類加載完成，在堆中生成字符串對象實例，然後將該字符串對象實例的引用值存到string pool中。
class文件常量池：用於存放編譯器生成的各種字面量(Literal)和符號引用(Symbolic References)。
運行時常量池：當類加載到內存中後，jvm就會將class常量池中的內容存放到運行時常量池中。
Java運行時常量池是什麼？
在class文件中，“常量池”是最複雜也最值得關注的內容。
Java是一種動態連接的語言，常量池的作用非常重要，常量池中除了包含代碼中所定義的各種基本類型（如int、long等等）和對象型（如String及數組）的常量值還，還包含一些以文本形式出現的符號引用，比如：
類和接口的全限定名；
字段的名稱和描述符；
方法和名稱和描述符。
在C語言中，如果一個程序要調用其它庫中的函數，在連接時，該函數在庫中的位置（即相對於庫文件開頭的偏移量）會被寫在程序中，在運行時，直接去這個地址調用函數；
而在Java語言中不是這樣，一切都是動態的。編譯時，如果發現對其它類方法的調用或者對其它類字段的引用的話，記錄進class文件中的，只能是一個文本形式的符號引用，在連接過程中，虛擬機根據這個文本信息去查找對應的方法或字段。
所以，與Java語言中的所謂“常量”不同，class文件中的“常量”內容很非富，這些常量集中在class中的一個區域存放，一個緊接着一個，這裡就稱為“常量池”。
java中的常量池技術，是為了方便快捷地創建某些對象而出現的，當需要一個對象時，就可以從池中取一個出來（如果池中沒有則創建一個），則在需要重複重複創建相等變量時節省了很多時間。常量池其實也就是一個內存空間，不同於使用new關鍵字創建的對象所在的堆空間。本文只從java使用者的角度來探討java常量池技術，並不涉及常量池的原理及實現方法。個人認為，如果是真的專註java,就必須對這些細節方面有一定的了解。但知道它的原理和具體的實現方法則不是必須的。
常量池中對象和堆中的對象
[java] view plain copy
public class Test{
Integer i1=new Integer(1);
Integer i2=new Integer(1);
//i1,i2分別位於堆中不同的內存空間
System.out.println(i1==i2);//輸出false
Integer i3=1;
Integer i4=1;
//i3,i4指向常量池中同一個內存空間
System.out.println(i3==i4);//輸出true
//很顯然，i1,i3位於不同的內存空間
System.out.println(i1==i3);//輸出false
}
8種基本類型的包裝類和對象池
java中基本類型的包裝類的大部分都實現了常量池技術，這些類是Byte,Short,Integer,Long,Character,Boolean,另外兩種浮點數類型的包裝類則沒有實現。另外Byte,Short,Integer,Long,Character這5種整型的包裝類也只是在對應值小於等於127時才可使用對象池，也即對象不負責創建和管理大於127的這些類的對象。以下是一些對應的測試代碼：
[java] view plain copy
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
}
}
String也實現了常量池技術
String類也是java中用得多的類，同樣為了創建String對象的方便，也實現了常量池的技術,測試代碼如下:
[java] view plain copy
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
}
}
最後
細節決定成敗，寫代碼更是如此。
在JDK5.0之前是不允許直接將基本數據類型的數據直接賦值給其對應地包裝類的，如：Integer i = 5;
但是在JDK5.0中支持這種寫法，因為編譯器會自動將上面的代碼轉換成如下代碼：Integer i=Integer.valueOf(5);
這就是Java的裝箱.JDK5.0也提供了自動拆箱. Integer i =5; int j = i;
Integer的封裝：
[java] view plain copy
public static Integer valueOf(int i) {
final int offset = 128;
if (i = -128 i = 127) { // must cache
return IntegerCache.cache[i + offset];
}
return new Integer(i);
}
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中，這樣可以在一定程度上提高效率。
原創文章，作者：VAYL，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/133125.html
微信掃一掃 
支付寶掃一掃 