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

本節主要介紹基本數據類型的大小，自動拆箱裝箱，基本數據類型的存儲方式，以及常量池的原理。

基本數據類型的大小：

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

　　

//8位
byte bx = Byte.MAX_VALUE;
byte bn = Byte.MIN_VALUE;
//16位
short sx = Short.MAX_VALUE;
short sn = Short.MIN_VALUE;
//32位
int ix = Integer.MAX_VALUE;
int in = Integer.MIN_VALUE;
//64位
long lx = Long.MAX_VALUE;
long ln = Long.MIN_VALUE;
//32位
float fx = Float.MAX_VALUE;
float fn = Float.MIN_VALUE;
//64位
double dx = Double.MAX_VALUE;
double dn = Double.MIN_VALUE;
//16位
char cx = Character.MAX_VALUE;
char cn = Character.MIN_VALUE;
//1位
boolean bt = Boolean.TRUE;
boolean bf = Boolean.FALSE;

自動拆箱和裝箱：

//基本數據類型的常量池是-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查找到常量池存在相同值的對象時會返回該對象的地址。

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

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