java Integer 源碼面試必備

時間 2020-03-17

標籤 java integer 源碼面試必備欄目 Java 简体版

原文原文鏈接

面試通常都會問到你看過源碼嗎，因此，我就參考了網上的資料和本身的看法寫了這篇源碼解讀。

概況

首先介紹 Integer和int的區別java

一、Integer是int的包裝類，int是java的一種基本數據類型
二、Integer變量必須實例化後才能使用，而int變量不須要
三、Integer實際是對象的引用，當new一個Integer時，其實是生成一個指針指向此對象；而int則是直接存儲數據值 git

非new生成的Integer變量指向的是java常量池中的對象，而new Integer()生成的變量指向堆中新建的對象，二者在內存中的地址不一樣）面試

Integer a = new Integer(99);
Integer b = 99;
System.out.print(a== b); 
//false

四、Integer的默認值是null，int的默認值是0數組

Java的Ingeter是int的包裝類,在開發中咱們基本能夠將二者等價。緩存

Integer類是對int進行封裝,裏面包含處理int類型的方法，好比int到String類型的轉換方法或String類型轉int類型的方法，也有與其餘類型之間的轉換方，固然也包括操做位的方法。less

主要屬性

Integer的界限範圍是 0x7fffffff~0x80000000 這與int類型的界限範圍是同樣的。函數

在Integer類中是這樣聲明的。post

//MIN_VALUE靜態變量表示int能取的最小值，爲-2的31次方，被final修飾說明不可變。
public static final int   MIN_VALUE = 0x80000000;
//相似的還有MAX_VALUE，表示int最大值爲2的31次方減1。
public static final int   MAX_VALUE = 0x7fffffff;
public static final int SIZE = 32;

SIZE用來表示二進制補碼形式的int值的比特數，值爲32，由於是靜態變量因此值不可變。ui

因爲補碼錶示負數的關係。正數老是比負數多一個來，因此：this

MIN_VALUE表示int能取的最小值，爲-2的31次方。

MAX_VALUE表示int能取最大值，爲2的31次方減1。

public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

還有一個是這個，這個應該是指類型，類型是int。

final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                      99999999, 999999999, Integer.MAX_VALUE };
// Requires positive xstatic int stringSize(int x) {
    for (int i=0; ; i++)
        if (x <= sizeTable[i])
            return i+1;
}

stringSize主要是爲了判斷一個int型數字對應字符串的長度。sizeTable這個數組存儲了該位數的最大值。

final static char[] digits = {
        '0' , '1' , '2' , '3' , '4' , '5' ,
        '6' , '7' , '8' , '9' , 'a' , 'b' ,
        'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
        'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
        'o' , 'p' , 'q' , 'r' , 's' , 't' ,
        'u' , 'v' , 'w' , 'x' , 'y' , 'z'
    };

digits數組裏面存的是數字從二進制到36進制所表示的字符，因此須要有36個字符才能表示全部不用進制的數字。

final static char [] DigitTens = {
        '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
        '1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
        '2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
        '3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
        '4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
        '5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
        '6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
        '7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
        '8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
        '9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
        } ;

final static char [] DigitOnes = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        } ;

DigitTens和DigitOnes兩個數組，DigitTens數組是爲了獲取0到99之間某個數的十位,DigitOnes是爲了獲取0到99之間某個數的個位

IntegerCache內部類

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) {
            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;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
    }

    private IntegerCache() {}
}

IntegerCache是Integer的一個靜態內部類，它包含了int可能值得Integer數組，它負責存儲了(high -low)個靜態Integer對象，並切在靜態代碼塊中初始化。默認範圍是【-128,127】，因此這裏默認只實例化了256個Integer對象，當Integer的值範圍在【-128,127】時則直接從緩存中獲取對應的Integer對象，沒必要從新實例化。這些緩存值都是靜態且final的，避免重複的實例化和回收。

若是不去配置虛擬機參數，這個值不會變。配合valueOf(int) 方法，能夠節省建立對象形成的資源消耗。另外若是想改變這些值緩存的範圍，再啓動JVM時能夠經過-Djava.lang.Integer.IntegerCache.high=xxx就能夠改變緩存值的最大值，好比-Djava.lang.Integer.IntegerCache.high=888則會緩存[-888]。

方法

parseInt

public static int parseInt(String s) throws NumberFormatException {
    return parseInt(s,10);
}
public static int parseInt(String s, int radix)
            throws NumberFormatException
{
    /*
     * WARNING: This method may be invoked early during VM initialization
     * before IntegerCache is initialized. Care must be taken to not use
     * the valueOf method.
     */

    if (s == null) {
        throw new NumberFormatException("null");
    }

    if (radix < Character.MIN_RADIX) {
        throw new NumberFormatException("radix " + radix +
                                        " less than Character.MIN_RADIX");
    }

    if (radix > Character.MAX_RADIX) {
        throw new NumberFormatException("radix " + radix +
                                        " greater than Character.MAX_RADIX");
    }

    int result = 0;
    boolean negative = false;
    int i = 0, len = s.length();
    int limit = -Integer.MAX_VALUE;
    int multmin;
    int digit;

    if (len > 0) {
        char firstChar = s.charAt(0);
        if (firstChar < '0') { // Possible leading "+" or "-"
            if (firstChar == '-') {
                negative = true;
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+')
                throw NumberFormatException.forInputString(s);

            if (len == 1) // Cannot have lone "+" or "-"
                throw NumberFormatException.forInputString(s);
            i++;
        }
        multmin = limit / radix;
        while (i < len) {
            // Accumulating negatively avoids surprises near MAX_VALUE
            digit = Character.digit(s.charAt(i++),radix);
            if (digit < 0) {
                throw NumberFormatException.forInputString(s);
            }
            if (result < multmin) {
                throw NumberFormatException.forInputString(s);
            }
            result *= radix;
            if (result < limit + digit) {
                throw NumberFormatException.forInputString(s);
            }
            result -= digit;
        }
    } else {
        throw NumberFormatException.forInputString(s);
    }
    return negative ? result : -result;
}

有兩個parseInt方法，這裏就是java的overload(重載)了，之後再介紹，第一個參數是須要轉換的字符串，第二個參數表示進制數（好比2,8,10）。

源碼裏已經給出了例子：

* parseInt("0", 10) returns 0
* parseInt("473", 10) returns 473
* parseInt("+42", 10) returns 42
* parseInt("-0", 10) returns 0
* parseInt("-FF", 16) returns -255
* parseInt("1100110", 2) returns 102
* parseInt("2147483647", 10) returns 2147483647
* parseInt("-2147483648", 10) returns -2147483648
* parseInt("2147483648", 10) throws a NumberFormatException
* parseInt("99", 8) throws a NumberFormatException
* parseInt("Kona", 10) throws a NumberFormatException
* parseInt("Kona", 27) returns 411787d

可是Integer.parseInt("10000000000",10)，會拋出java.lang.NumberFormatException異常,由於超過了Integer的最大的範圍了。

該方法的邏輯：

1.判斷字符串不爲空，而且傳進來進制參數在 Character.MIN_RADIX ，Charcater.MAX_RADIX 之間，即2和36。

2.判斷輸入的字符串長度必須大於0，再根據第一個字符串多是數字或負號或正號進行處理。

3.以後就是核心邏輯了，字符串轉換數字。

例如

127 轉換成8進制 1*8*8+2*8+7*1=87

127轉換成十進制 1*10*10+2*10+7*1=127

從左到右遍歷字符串，而後乘上進制數，再加上下一個字符，接着再乘以進制數，再加上下個字符，不斷重複，直到最後一個字符。

這裏也是經過計算負數再添加符號位的方式避免Integer.MIN_VALUE單獨處理的問題，，由於負數Integer.MIN_VALUE變化爲正數時會致使數值溢出，因此所有都用負數來運算。這裏使用了一個mulmin變量來避免數字溢出的問題，單純的使用正負號不能準確判斷是否溢出(一次乘法致使溢出的結果符號不肯定)。

構造函數

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

public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10);
    }

這兩種構造函數，一個是傳int類型，一個是String類型。第二種是經過調用parseInt方法進行轉換的。

getChars方法

static void getChars(int i, int index, char[] buf) {
    int q, r;
    int charPos = index;
    char sign = 0;

    if (i < 0) {
        sign = '-';
        i = -i;
    }

    // Generate two digits per iteration
    while (i >= 65536) {
        q = i / 100;
    // really: r = i - (q * 100);
        r = i - ((q << 6) + (q << 5) + (q << 2));
        i = q;
        buf [--charPos] = DigitOnes[r];
        buf [--charPos] = DigitTens[r];
    }

    // Fall thru to fast mode for smaller numbers
    // assert(i <= 65536, i);
    for (;;) {
        q = (i * 52429) >>> (16+3);
        r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...
        buf [--charPos] = digits [r];
        i = q;
        if (i == 0) break;
    }
    if (sign != 0) {
        buf [--charPos] = sign;
    }
}

該方法主要作的事情是將某個int型數值放到char數組裏面。

這裏面處理用了一些技巧，int高位的兩個字節和低位的兩個字節分開處理，

while (i >= 65536)部分就是處理高位的兩個字節，大於65536的部分使用了除法，一次生成兩位十進制字符，每次處理2位數，其實((q << 6) + (q << 5) + (q << 2))其實等於q*100,DigitTens和DigitOnes數組前面已經講過它的做用了，用來獲取十位和個位。

小於等於65536的部分使用了乘法加位移作成除以10的效果，好比(i * 52429) >>> (16+3)其實約等於i/10，((q << 3) + (q << 1))其實等於q*10，而後再經過digits數組獲取到對應的字符。能夠看到低位處理時它儘可能避開了除法，取而代之的是用乘法和右移來實現，可見除法是一個比較耗時的操做，比起乘法和移位。另外也能夠看到能用移位和加法來實現乘法的地方也儘可能不用乘法，這也說明乘法比起它們更加耗時。而高位處理時沒有用移位是由於作乘法後可能會溢出。

toString方法

public static String toString(int i) {
        if (i == Integer.MIN_VALUE)
            return "-2147483648";
        int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
        char[] buf = new char[size];
        getChars(i, size, buf);
        return new String(buf, true);
    }
public String toString() {
        return toString(value);
    }
public static String toString(int i, int radix) {
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;

        if (radix == 10) {
            return toString(i);
        }

        char buf[] = new char[33];
        boolean negative = (i < 0);
        int charPos = 32;

        if (!negative) {
            i = -i;
        }

        while (i <= -radix) {
            buf[charPos--] = digits[-(i % radix)];
            i = i / radix;
        }
        buf[charPos] = digits[-i];

        if (negative) {
            buf[--charPos] = '-';
        }

        return new String(buf, charPos, (33 - charPos));
    }

這裏有三個toString 方法。

第一個toString方法很簡單，就是先用stringSize獲得數字是多少位，再用getChars獲取數字對應的char數組，最後返回一個String類型。

第二個更簡單了，就是調用第一個toString方法。

第三個toString方法是帶了進制信息的，它會轉換成對應進制的字符串。不在2到36進制範圍之間的都會按照10進制處理。

valueOf方法

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
    }
public static Integer valueOf(String s, int radix) throws NumberFormatException {
        return Integer.valueOf(parseInt(s,radix));
    }

第一個valueOf中，由於IntegerCache緩存了【low,high】值的Integer對象，對於在【-128,127】範圍內的直接從IntegerCache的數組中獲取對應的Integer對象便可，而在範圍外的則須要從新實例化了。

第二個和第三個都是調用第一個valueOf方法，只不過調用的parseInt（）的方法不同。

decode方法

public static Integer decode(String nm) throws NumberFormatException {
    int radix = 10;
    int index = 0;
    boolean negative = false;
    Integer result;

    if (nm.length() == 0)
        throw new NumberFormatException("Zero length string");
    char firstChar = nm.charAt(0);
    // Handle sign, if present
    if (firstChar == '-') {
        negative = true;
        index++;
    } else if (firstChar == '+')
        index++;

    // Handle radix specifier, if present
    if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
        index += 2;
        radix = 16;
    }
    else if (nm.startsWith("#", index)) {
        index ++;
        radix = 16;
    }
    else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
        index ++;
        radix = 8;
    }

    if (nm.startsWith("-", index) || nm.startsWith("+", index))
        throw new NumberFormatException("Sign character in wrong position");

    try {
        result = Integer.valueOf(nm.substring(index), radix);
        result = negative ? Integer.valueOf(-result.intValue()) : result;
    } catch (NumberFormatException e) {
        // If number is Integer.MIN_VALUE, we'll end up here. The next line
        // handles this case, and causes any genuine format error to be
        // rethrown.
        String constant = negative ? ("-" + nm.substring(index))
                                   : nm.substring(index);
        result = Integer.valueOf(constant, radix);
    }
    return result;
}

decode方法主要做用是對字符串進行解碼。

默認會處理成十進制，0開頭的都會處理成8進制，0x和#開頭的都會處理成十六進制。

xxxvalue方法（byteValue，shortValue，intValue，longValue，floatValue，doubleValue）

public byte byteValue() {
        return (byte)value;
    }
public short shortValue() {
        return (short)value;
    }
public int intValue() {
        return value;
    }
public long longValue() {
        return (long)value;
    }
public float floatValue() {
        return (float)value;
    }
public double doubleValue() {
        return (double)value;
    }

其實就是轉換成對應的類型

hashCode方法

public int hashCode() {
    return value;
}

就是返回int類型的值

equals方法

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

比較是否相同以前會將int類型經過valueof轉換成Integer類型，equals本質就是值得比較

compare方法

public static int compare(int x, int y) {      

    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

x小於y則返回-1，相等則返回0，不然返回1。

bitCount方法

該方法主要用於計算二進制數中1的個數。

這些都是移位和加減操做。

0x55555555等於01010101010101010101010101010101，0x33333333等於110011001100110011001100110011，0x0f0f0f0f等於1111000011110000111100001111。

先每兩位一組統計看有多少個1，好比10011111則每兩位有一、一、二、2個1，記爲01011010，而後再算每四位一組看有多少個1，而01011010則每四位有二、4個1，記爲00100100，接着每八位一組就爲00000110，接着16位，32位，最終在與0x3f進行與運算，獲得的數即爲1的個數。

highestOneBit方法

public static int highestOneBit(int i) {
        // HD, Figure 3-1
        i |= (i >>  1);
        i |= (i >>  2);
        i |= (i >>  4);
        i |= (i >>  8);
        i |= (i >> 16);
        return i - (i >>> 1);
    }
// 隨便一個例子，不用管最高位以後有多少個1，都會被覆蓋
// 00010000 00000000 00000000 00000000      raw
// 00011000 00000000 00000000 00000000      i | (i >> 1)
// 00011110 00000000 00000000 00000000      i | (i >> 2)
// 00011111 11100000 00000000 00000000      i | (i >> 4)
// 00011111 11111111 11100000 00000000      i | (i >> 8)
// 00011111 11111111 11111111 11111111      i | (i >> 16)
// 00010000 0000000 00000000 00000000       i - (i >>>1)

這個方法是返回最高位的1，其餘都是0的值。將i右移一位再或操做，則最高位1的右邊也爲1了，接着再右移兩位並或操做，則右邊1+2=3位都爲1了，接着1+2+4=7位都爲1，直到1+2+4+8+16=31都爲1，最後用i - (i >>> 1)天然獲得最終結果。

lowestOneBit方法

public static int lowestOneBit(int i) {
        // HD, Section 2-1
        return i & -i;
    }
// 例子
// 00001000 10000100 10001001 00101000    i
// 11110111 01111011 01110110 11011000    -i
// 00000000 00000000 00000000 00001000  i & -i

與highestOneBit方法對應，lowestOneBit獲取最低位1，其餘全爲0的值。這個操做較簡單，先取負數，這個過程須要對正數的i取反碼而後再加1，獲得的結果和i進行與操做，恰好就是最低位1其餘爲0的值了。

numberOfLeadingZeros方法

public static int numberOfLeadingZeros(int i) {
        // HD, Figure 5-6
        if (i == 0)
            return 32;
        int n = 1;
        if (i >>> 16 == 0) { n += 16; i <<= 16; }
        if (i >>> 24 == 0) { n +=  8; i <<=  8; }
        if (i >>> 28 == 0) { n +=  4; i <<=  4; }
        if (i >>> 30 == 0) { n +=  2; i <<=  2; }
        n -= i >>> 31;
        return n;
    }
// 方法很巧妙， 相似於二分法。不斷將數字左移縮小範圍。例子用最差狀況：
// i: 00000000 00000000 00000000 00000001         n = 1
// i: 00000000 00000001 00000000 00000000         n = 17
// i: 00000001 00000000 00000000 00000000         n = 25
// i: 00010000 00000000 00000000 00000000         n = 29
// i: 01000000 00000000 00000000 00000000         n = 31
// i >>>31 == 0
// return 31

該方法返回i的二進制從頭開始有多少個0。i爲0的話則有32個0。這裏處理實際上是體現了二分查找思想的，先看高16位是否爲0，是的話則至少有16個0，不然左移16位繼續往下判斷，接着右移24位看是否是爲0，是的話則至少有16+8=24個0，直到最後獲得結果。

numberOfTrailingZeros方法

public static int numberOfTrailingZeros(int i) {
        // HD, Figure 5-14
        int y;
        if (i == 0) return 32;
        int n = 31;
        y = i <<16; if (y != 0) { n = n -16; i = y; }
        y = i << 8; if (y != 0) { n = n - 8; i = y; }
        y = i << 4; if (y != 0) { n = n - 4; i = y; }
        y = i << 2; if (y != 0) { n = n - 2; i = y; }
        return n - ((i << 1) >>> 31);
    }
// 與求開頭多少個0相似，也是用了二分法，先鎖定1/2, 再鎖定1/4，1/8，1/16，1/32。
// i: 11111111 11111111 11111111 11111111    n: 31
// i: 11111111 11111111 00000000 00000000    n: 15
// i: 11111111 00000000 00000000 00000000    n: 7
// i: 11110000 00000000 00000000 00000000    n: 3
// i: 11000000 00000000 00000000 00000000    n: 1
// i: 10000000 00000000 00000000 00000000    n: 0

與前面的numberOfLeadingZeros方法對應，該方法返回i的二進制從尾開始有多少個0。它的思想和前面的相似，也是基於二分查找思想，詳細步驟再也不贅述。

reverse方法

public static int reverse(int i) {
        i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
        i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
        i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
        i = (i << 24) | ((i & 0xff00) << 8) |
            ((i >>> 8) & 0xff00) | (i >>> 24);
        return i;
    }

該方法便是將i進行反轉，反轉就是第1位與第32位對調，第二位與第31位對調，以此類推。它的核心思想是先將相鄰兩位進行對換，好比10100111對換01011011，接着再將相鄰四位進行對換，對換後爲10101101，接着將相鄰八位進行對換，最後把32位中中間的16位對換，而後最高8位再和最低8位對換。

toHexString和toOctalString方法

public static String toHexString(int i) {
        return toUnsignedString0(i, 4);
    }
public static String toOctalString(int i) {
        return toUnsignedString0(i, 3);
    }
private static String toUnsignedString0(int val, int shift) {
        int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
        int chars = Math.max(((mag + (shift - 1)) / shift), 1);
        char[] buf = new char[chars];

        formatUnsignedInt(val, shift, buf, 0, chars);

        return new String(buf, true);
    }
static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
        int charPos = len;
        int radix = 1 << shift;
        int mask = radix - 1;
        do {
            buf[offset + --charPos] = Integer.digits[val & mask];
            val >>>= shift;
        } while (val != 0 && charPos > 0);

        return charPos;
    }

這兩個方法相似，合到一塊兒講。看名字就知道轉成8進制和16進制的字符串。能夠看到都是間接調用toUnsignedString0方法，該方法會先計算轉換成對應進制須要的字符數，而後再經過formatUnsignedInt方法來填充字符數組，該方法作的事情就是使用進制之間的轉換方法（前面有提到過）來獲取對應的字符。

=====================================================

參考出處：https://juejin.im/post/5992b1986fb9a03c3223ce32