java中常量池技,java運行時常量池

本文目錄一覽：

• 1、java常量池是什麼
• 2、常量池的具體結構
• 3、Java運行時常量池是什麼？
• 4、Java中的幾種常量池

java常量池是什麼

1. 首先String不屬於8種基本數據類型，String是一個對象。

因為對象的默認值是null，所以String的默認值也是null；但它又是一種特殊的對象，有其它對象沒有的一些特性。

2. new String()和new String(“”)都是申明一個新的空字符串，是空串不是null；

3. String str=”kvill”；

String str=new String (“kvill”);的區別：

在這裡，我們不談堆，也不談棧，只先簡單引入常量池這個簡單的概念。

常量池(constant pool)指的是在編譯期被確定，並被保存在已編譯的.class文件中的一些數據。它包括了關於類、方法、接口等中的常量，也包括字符串常量。

看例1：

Java代碼

String s0=”kvill”;

String s1=”kvill”;

String s2=”kv” + “ill”;

System.out.println( s0==s1 );

System.out.println( s0==s2 );

String s0=”kvill”;

String s1=”kvill”;

String s2=”kv” + “ill”;

System.out.println( s0==s1 );

System.out.println( s0==s2 );

結果為：

true

true

首先，我們要知道Java會確保一個字符串常量只有一個拷貝。

因為例子中的s0和s1中的”kvill”都是字符串常量，它們在編譯期就被確定了，所以s0==s1為true；而”kv”和”ill”也都是字符串常量，當一個字符串由多個字符串常量連接而成時，它自己肯定也是字符串常量，所以s2也同樣在編譯期就被解析為一個字符串常量，所以s2也是常量池中”kvill”的一個引用。

所以我們得出s0==s1==s2;

用new String() 創建的字符串不是常量，不能在編譯期就確定，所以new String() 創建的字符串不放入常量池中，它們有自己的地址空間。

看例2：

Java代碼

String s0=”kvill”;

String s1=new String(”kvill”);

String s2=”kv” + new String(“ill”);

System.out.println( s0==s1 );

System.out.println( s0==s2 );

System.out.println( s1==s2 );

String s0=”kvill”;

String s1=new String(”kvill”);

String s2=”kv” + new String(“ill”);

System.out.println( s0==s1 );

System.out.println( s0==s2 );

System.out.println( s1==s2 ); 結果為：

false

false

false

例2中s0還是常量池中”kvill”的應用，s1因為無法在編譯期確定，所以是運行時創建的新對象”kvill”的引用，s2因為有後半部分new String(“ill”)所以也無法在編譯期確定，所以也是一個新創建對象”kvill”的應用;明白了這些也就知道為何得出此結果了。

4. String.intern()：

再補充介紹一點：存在於.class文件中的常量池，在運行期被JVM裝載，並且可以擴充。String的intern()方法就是擴充常量池的一個方法；當一個String實例str調用intern()方法時，Java查找常量池中是否有相同Unicode的字符串常量，如果有，則返回其的引用，如果沒有，則在常量池中增加一個Unicode等於str的字符串並返回它的引用；看例3就清楚了

例3：

Java代碼

String s0= “kvill”;

String s1=new String(”kvill”);

String s2=new String(“kvill”);

System.out.println( s0==s1 );

System.out.println( “**********” );

s1.intern();

s2=s2.intern(); //把常量池中“kvill”的引用賦給s2

System.out.println( s0==s1);

System.out.println( s0==s1.intern() );

System.out.println( s0==s2 );

String s0= “kvill”;

String s1=new String(”kvill”);

String s2=new String(“kvill”);

System.out.println( s0==s1 );

System.out.println( “**********” );

s1.intern();

s2=s2.intern(); //把常量池中“kvill”的引用賦給s2

System.out.println( s0==s1);

System.out.println( s0==s1.intern() );

System.out.println( s0==s2 ); 結果為：

false

**********

false //雖然執行了s1.intern(),但它的返回值沒有賦給s1

true //說明s1.intern()返回的是常量池中”kvill”的引用

true

最後我再破除一個錯誤的理解：

有人說，“使用String.intern()方法則可以將一個String類的保存到一個全局String表中，如果具有相同值的Unicode字符串已經在這個表中，那麼該方法返回表中已有字符串的地址，如果在表中沒有相同值的字符串，則將自己的地址註冊到表中“如果我把他說的這個全局的String表理解為常量池的話，他的最後一句話，“如果在表中沒有相同值的字符串，則將自己的地址註冊到表中”是錯的：

看例4：

Java代碼

String s1=new String(“kvill”);

String s2=s1.intern();

System.out.println( s1==s1.intern() );

System.out.println( s1+” “+s2 );

System.out.println( s2==s1.intern() );

String s1=new String(“kvill”);

String s2=s1.intern();

System.out.println( s1==s1.intern() );

System.out.println( s1+” “+s2 );

System.out.println( s2==s1.intern() );

結果：

false

kvill kvill

true

在這個類中我們沒有聲名一個”kvill”常量，所以常量池中一開始是沒有”kvill”的，當我們調用s1.intern()後就在常量池中新添加了一個”kvill”常量，原來的不在常量池中的”kvill”仍然存在，也就不是“將自己的地址註冊到常量池中”了。

s1==s1.intern()為false說明原來的“kvill”仍然存在；

s2現在為常量池中“kvill”的地址，所以有s2==s1.intern()為true。

5. 關於equals()和==:

這個對於String簡單來說就是比較兩字符串的Unicode序列是否相當，如果相等返回true;而==是比較兩字符串的地址是否相同，也就是是否是同一個字符串的引用。

6. 關於String是不可變的

這一說又要說很多，大家只要知道String的實例一旦生成就不會再改變了，比如說：String str=”kv”+”ill”+” “+”ans”;

就是有4個字符串常量，首先”kv”和”ill”生成了”kvill”存在內存中，然後”kvill”又和” “ 生成 ”kvill “存在內存中，最後又和生成了”kvill ans”;並把這個字符串的地址賦給了str,就是因為String的“不可變”產生了很多臨時變量，這也就是為什麼建議用StringBuffer的原因了，因為StringBuffer是可改變的

常量池的具體結構

在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運行時常量池是什麼？

在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中，這樣可以在一定程度上提高效率。

Java中的幾種常量池

字符串常量池：當類加載完成，在堆中生成字符串對象實例，然後將該字符串對象實例的引用值存到string pool中。

class文件常量池：用於存放編譯器生成的各種字面量(Literal)和符號引用(Symbolic References)。

運行時常量池：當類加載到內存中後，jvm就會將class常量池中的內容存放到運行時常量池中。