1. 程式人生 > >Java基礎2:基本數據類型與常量池

Java基礎2:基本數據類型與常量池

cache model ria 比較 是否 類型 misc pri pan

Java基礎2:基本數據類型與常量池

基本數據類型的大小

int 324字節  
short 16
float 32
double 64
long 64
char 16
byte 8
boolean 1
//自動拆箱和裝箱的意思就是,計算數值時,integer會自動轉為int進行計算。
//而當int傳入類型為integer的引用時,int數值又會被包裝為integer。

自動拆箱和裝箱

//基本數據類型的常量池是-128到127之間。
// 在這個範圍中的基本數據類的包裝類可以自動拆箱,比較時直接比較數值大小。
public static void main(String[] args) {
//int的自動拆箱和裝箱只在-128到127範圍中進行,超過該範圍的兩個integer的 == 判斷是會返回false的。
Integer a1 = 128;
Integer a2 = -128;
Integer a3 = -128;
Integer a4 = 128;
System.out.println(a1 == a4);
System.out.println(a2 == a3);
Byte b1 = 127;
Byte b2 = 127;
Byte b3 = -128;
Byte b4 = -128;
//byte都是相等的,因為範圍就在-128到127之間
System.out.println(b1 == b2);
System.out.println(b3 == b4);
?
//
Long c1 = 128L;
Long c2 = 128L;
Long c3 = -128L;
Long c4 = -128L;
System.out.println(c1 == c2);
System.out.println(c3 == c4);
?
//char沒有負值
//發現char也是在0到127之間自動拆箱
Character d1 = 128;
Character d2 = 128;
Character d3 = 127;
Character d4 = 127;
System.out.println(d1 == d2);
System.out.println(d3 == d4);
Integer i = 10;
Byte b = 10;
//比較Byte和Integer.兩個對象無法直接比較,報錯
//System.out.println(i == b);
System.out.println("i == b " + i.equals(b));
//答案是false,因為包裝類的比較時先比較是否是同一個類,不是的話直接返回false.
int ii = 128;
short ss = 128;
long ll = 128;
char cc = 128;
System.out.println("ii == bb " + (ii == ss));
System.out.println("ii == ll " + (ii == ll));
System.out.println("ii == cc " + (ii == cc));
//這時候都是true,因為基本數據類型直接比較值,值一樣就可以。

總結:註意基本數據類型的拆箱裝箱,以及對常量池的理解。

基本數據類型的存儲方式 上面自動拆箱和裝箱的原理其實與常量池有關。 3.1存在棧中: public void(int a) { int i = 1; int j = 1; } 方法中的i 存在虛擬機棧的局部變量表裏,i是一個引用,j也是一個引用,它們都指向局部變量表裏的整型值 1. int a是傳值引用,所以a也會存在局部變量表。

3.2存在堆裏: class A{ int i = 1; A a = new A(); } i是類的成員變量。類實例化的對象存在堆中,所以成員變量也存在堆中,引用a存的是對象的地址,引用i存的是值,這個值1也會存在堆中。可以理解為引用i指向了這個值1。也可以理解為i就是1.

3.3包裝類對象怎麽存 其實我們說的常量池也可以叫對象池 比如String a= new String("a").intern()時會先在常量池找是否有“a"對象如果有的話直接返回“a"對象在常量池的地址,即讓引用a指向常量”a"對象的內存地址。 public native String intern(); Integer也是同理。

下圖是Integer類型在常量池中查找同值對象的方法。

public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
?
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
?
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
?
private IntegerCache() {}

所以基本數據類型的包裝類型可以在常量池查找對應值的對象,找不到就會自動在常量池創建該值的對象。

而String類型可以通過intern來完成這個操作。

JDK1.7後,常量池被放入到堆空間中,這導致intern()函數的功能不同,具體怎麽個不同法,且看看下面代碼,這個例子是網上流傳較廣的一個例子,分析圖也是直接粘貼過來的,這裏我會用自己的理解去解釋這個例子:

// java view plain copy
String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2);
?
String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4);
輸出結果為:
?
[java] view plain copy
//JDK1.6以及以下:false false
//JDK1.7以及以上:false true

JDK1.6查找到常量池存在相同值的對象時會直接返回該對象的地址。

JDK 1.7後,intern方法還是會先去查詢常量池中是否有已經存在,如果存在,則返回常量池中的引用,這一點與之前沒有區別,區別在於,如果在常量池找不到對應的字符串,則不會再將字符串拷貝到常量池,而只是在常量池中生成一個對原字符串的引用。

那麽其他字符串在常量池找值時就會返回另一個堆中對象的地址。

Java基礎2:基本數據類型與常量池