java常量池技術 java中的常量池技術,是爲了方便快捷地創建某些對象而出現的,當需要一個對象時,就可以從池中取一個出來(如果池中沒有則創建一個),則在需要重複創建相等變量時節省了很多時間。常量池其實也就是一個內存空間,不同於使用new關鍵字創建的對象所在的堆空間。
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同時指向常量池中的常量值"text",b=b+"java"之後,b原先指向一個常量,內容爲"test”,通過對b進行+"java" 操作後,b之前所指向的那個值沒有改變,但此時b不指向原來那個變量值了,而指向了另一個String變量,內容爲”text 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