Java源碼解讀掃盲【Integer】

1、類的描述

Integer 是基本數據類型int的封裝類，用來表示基本數據類型int的面向對象的類，類中包含了原始類型int的值以及int操做的方法

2、源碼解析

public final class Integer extends Number implements Comparable<Integer> {
//Integer的值
private final int value;

public Integer(int value) {
    this.value = value;
}

//由字符串來初始化Integer 默認轉換爲10進制
public Integer(String s) throws NumberFormatException {
    this.value = parseInt(s, 10);
}

public static int hashCode(int value) {
    return value;
}

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue(); //比較兩個Integer的int值
    }
    return false;
}

public int compareTo(Integer anotherInteger) {
    return compare(this.value, anotherInteger.value);
}

public static int compare(int x, int y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1); //比較x,y的大小，x<y返回-1，x=y返回0，x>y返回1
}

//內部字符緩存類
private static class IntegerCache {
    //緩存的下界，-128，不可變  
    static final int low = -128;
    //緩存上界，暫爲null
    static final int high;
    static final Integer cache[]; //利用數組來緩存

    static {
        // high value may be configured by property
        // 緩存上屆，能夠經過JVM屬性來配置
        int h = 127;
        String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        //獲取
        if (integerCacheHighPropValue != null) {
            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);
        }
        high = h;

        //獲取Integer中全部能保存的數據
        cache = new Integer[(high - low) + 1];
        int j = low;
        //緩存全部Integer的數據
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
    }

    private IntegerCache() {}
}

這是一個內部靜態類，該類只能在Integer這個類的內部訪問，這個類在初始化的時候，會去加載JVM的配置，若是有值，就用配置的值初始化緩存數組，不然就緩存-128到127之間的值。

public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127; //斷言Integer緩存中的上屆必須大於或等於127
    if (i >= IntegerCache.low && i <= IntegerCache.high) //若是i在Integer緩存中，則直接取出
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i); //不然，直接建立一個實例
}

好比：Integer a = 127 的執行過程，首先調用Integer.valueOf(127) ,因爲127在-128到127之間（看上面的源碼），因此返回一個緩存值 return IntegerCache.cache[127+128];也就是數組中下標是255的值127

3、相等判斷

關於 == 的運行結果,只要咱們記住一條:他比較的是引用(地址) 就行了,按照這個來分析結果

當且僅當比較的兩個引用指向同一對象才返回true

舉例

Integer a = new Integer(100);
Integer b = new Integer(100);
int c=100;
Integer d = 100;
Integer e = 128;
Integer f = 128;
System.out.println("a==b:"+(a==b));
System.out.println("a==c:"+(a==c));
System.out.println("a==d:"+(a==d));
System.out.println("c==d:"+(c==d));
System.out.println("e==f:"+(e==f));

運行結果

a==b:false
a==c:true
a==d:false
c==d:true
e==f:false

Integer是int的封裝對象，兩個對象==比較的是棧的值。
Integer a = new Integer(100);
Integer b = new Integer(100);
a與b在棧中，存的是Integer對象在堆中的地址，而不是值，a、b指向堆中的地址顯然不一樣因此 a==b 爲false

int c = 100;

由於int爲值類型，引用類型Integer與值類型int比較顯然比較的是值。
由於int在堆中是不開闢內存的，他在棧中的值則爲他自己的值
因此a==c比較的是他們各自的value，Integer對象會自動拆箱， a==c爲true

Integer d = 100;

c和d的標記同a和c的比較,c==d爲true

Integer e = 128;

Integer f = 128;

實際就是調用Interger.valueOf(100),經過上面源碼知道首先判斷100是否在-128-127 之間，若是是直接return 已經存在的對象，不然就只能new 一個了，因此 e==f爲false