JDK原始碼閱讀-Integer類

七印miss發表於2019-01-12
JDK原始碼

概要

Integer類包裝一個物件中的原始型別int的值。此外，該類還提供了一些int和其他基本資料型別、String型別之間的互轉，以及在處理int時有用的其他常量和方法。

Number類圖

類定義

public final class Integer extends Number implements Comparable<Integer>;
複製程式碼

從類定義中可看出：

  1. Integer是final類，不能被繼承
  2. Integer實現了Comparable介面，因此存在compareTo(Integer i)方法
  3. Integer繼承了Number類，因此需要實現不同基本資料型別之間的轉換

構造方法

Integer有兩個構造方法

public Integer(int value)

構造新分配的 Integer物件，該物件表示指定的int值。其實現簡單的將入參賦給私有欄位value：

public Integer(int value){
    this.value = value;
}
複製程式碼

public Integer(String s) throws NumberFormatException

構造一個新分配Integer物件，表示字串引數將轉換為int值，正好與基數為parseInt方法一樣。其呼叫了parseInt(java.lang.String, int)方法將入參字串解析為int型別：

public Integer(String s) throws NumberFormatException {
    this.value = parseInt(s, 10);
}
複製程式碼

內部類IntegerCache

IntegerCache是Integer的一個內部類，主要包含了一個靜態且final的cache陣列，用來快取部分經常用到的Integer物件，避免重複的例項化和回收。預設情況下，只快取[-128,127]範圍內的Integer物件。當新的一個Integer物件初始化時，如果其值再cache範圍內則直接從快取中獲取對應的Integer物件，不必重新例項化。另外我們可以改變這些值快取的範圍，再啟動JVM時通過-Djava.lang.Integer.IntegerCache.high=xxx就可以改變快取值的最大值。

    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() {}
    }

複製程式碼

欄位

Integer欄位

私有欄位

value

Integer私有欄位value真正儲存其值的變數：private final int value;。value被定義成final型別，也就是說，一旦一個Integer物件使用第一種構造方法初始化後，value值就無法再改變了。初始化後如果嘗試重新賦值，則會呼叫Integer.valueOf()來直接返回一個已有物件或新建一個物件，而不會改變原有的Integer物件。
如下程式碼：

public class IntegerTest{
    public static void main(String[] args){
        Integer i = new Integer(1);
        i = 2;
    }
}
複製程式碼

則編譯之後的程式碼實際為：

public class IntegerTest{
    public Integer(){
    }
    
    public static void main(String[] args){
        Integer i = new Integer(1);
        i = Integer.valueOf(2);
    }
}
複製程式碼

default欄位

digits

所有可以表示成一個數字的字元，支援2-36進位制。

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'
    };
複製程式碼

DigitTens

個位上的數字陣列

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',
        } ;
複製程式碼

DigitOnes

十位上的數字陣列

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',
        } ;
複製程式碼

siteTable

配合stringSize()實現快速判斷int變數的位數

final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999,
                                      99999999, 999999999, Integer.MAX_VALUE };
複製程式碼

公共欄位

MIN_VALUE

靜態常量。表示int的最小值，-231

@Native public static final int MIN_VALUE = 0x80000000;
複製程式碼

MAX_VALUE

靜態常量。表示int的最大值，2^31-1

@Native public static final int MAX_VALUE = 0x7fffffff;
複製程式碼

TYPE

靜態常量。基本資料型別的包裝類中都有一個常量:TYPE,表示的是該包裝類對應的基本資料型別的Class例項。因此存在Integer.TYPE==int.class;//true和Integer.TYPE==Integer.class

public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");
複製程式碼

SIZE

靜態常量。用來表示二進位制補碼形式的int值的位元數，值為32。

public static final int SIZE = 32;
複製程式碼

BYTES

靜態常量。表示二進位制補碼形式的int值的位元組數，值為4。

public static final int BYTES = SIZE / Byte.SIZE;
複製程式碼

方法

bitCount

類方法。用於統計二進位制中"1"的個數

public static int bitCount(int i) {
        i = i - ((i >>> 1) & 0x55555555);
        i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
        i = (i + (i >>> 4)) & 0x0f0f0f0f;
        i = i + (i >>> 8);
        i = i + (i >>> 16);
        return i & 0x3f;
    }
複製程式碼

詳解參見：JDK原始碼閱讀-Integer.bitCount()

xxxValue

例項方法。與其他資料型別間的型別轉換，包括：

  • byteValue()：轉為byte型，需注意截斷
public byte byteValue() {
        return (byte)value;
    }
複製程式碼
  • shortValue()：轉為short型，需注意截斷
public short shortValue() {
        return (short)value;
    }
複製程式碼
  • intValue：獲取其值
public int intValue(){
    return value;
}
複製程式碼
  • longValue(): 轉為long型
public long longValue(){
    return (long) value;
}
複製程式碼
  • floatValue(): 轉為float型
public float floatValue(){
    return (float) value;
}
複製程式碼
  • doubleValue(): 轉為double型
public double longValue(){
    return (double) value;
}
複製程式碼

compare

類方法。比較兩個int值的大小，0:相等；1:前者不小於後者; -1: 前者小於後者。

compare(int, int)

public static int compare(int x, int y){
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
複製程式碼

compare(Integer)

public static int compare(Integer antherInteger){
    return compare(this.value, anotherInteger.value);
}
複製程式碼

compareTo

例項方法。比較兩個值的大小。

public int compareTo(Integer anotherInteger){
    return compare(this.value, anotherInteger.value);
}
複製程式碼

compareUnsigned

類方法。將兩個引數看做無符號整數，比較大小。最大值是-1,因為在計算機中負數用補碼儲存，-1的補碼為全1。方法實現中呼叫了compare(int, int)，而compare比較的是有符號數。有符號數中，負數永遠小於正數。這裡將兩個引數加上MIN_VALUE，即1000 0000 0000 0000 0000 0000 0000 0000，這樣的話只改變數字的最高位元位（符號位），不影響後面的數值位。所以負數的最高位變成了0，正數的最高位變成了1，自然在compare函式裡就分出大小來了。而非負數之間的比較並不受影響。since 1.8。

public static int compareUnsigned(int x, int y){
    return compare(x + MIN_VALUE, y + MIN_VALUE);
}
複製程式碼

parseInt

將整數字符串轉成對應進位制的int型別。與valueOf()相比，後者返回的是Integer型別。

parseInt(String s, int radix)

異常情況：

  1. 入參s為"null"或為空
  2. 入參radix超過Character中定義的進位制許可範圍: [2, 36]
  3. 入參s超過Integer範圍
  4. 入參s存在不能由指定基數的數字表示的字元（除了減號）
public static int parseInt(String s, int radix) throws NumberFormatException{
    if (s == null){
        return new NumberFormatException("null");
    }
    
    if (radix < Character.MIN_RADIX) {
        return new NumberFormatException("radix " + radix + " less than Character.MIN_RADIX");
    }
    
    if (radix > Character.MAX_RADIX) {
                return new NumberFormatException("radix " + radix + " greater than Character.MAX_RADIX");
    }
    
    int result = 0;
    boolean negative = false; //判斷正負號的標記，先初始化為正數
    int i = 0, len = s.length();
    //初始化limit 為負，因為之後每次的result是相減的形式
    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; //上一次的結果乘以radix進位制
            if (result < limit + digit) { // 處理溢位
                throw NumberFormatException.forInputString(s);
            }
            result -= digit;
        }
    } else {
        throw NumberFormatException.forInputString(s);
    }
    return negative ? result : -result;
}
複製程式碼

Q: 為啥要用減法來更新result，而不是直接用加法

parseInt(String)

直接呼叫parseInt(String, 10)方法。

public static int parseInt(String s) throws NumberFormatException {
    return parseInt(s, 10);
}
複製程式碼

valueOf

類方法。返回一個Integer物件，包含三種過載形式：

valueOf(int)

先嚐試從快取中獲取已經例項化好的Integer物件，當獲取失敗後才會new一個新物件。因此希望將int變數裝箱成Integer時，應使用valueOf()來代替建構函式。或直接使用Integer i = 100;，編譯器會轉成Integer i = Integer.valueOf(100)。

public static Integer valueOf(int i){
    // 首先嚐試從內部類IntegerCache的cache陣列中獲取
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    
    // cache不存在，則new一個新物件    
    return new Integer(i);
}
複製程式碼

valueOf(String)

所有能實現將String型別轉成Integer(int)型別的方法，都是基於parseInt()方法實現的。

public static Integer valueOf(String s) throws NumberFormatException {
    return Integer.valueOf(parseInt(s, 10));
}
複製程式碼

valueOf(String, int)

所有能實現將String型別轉成Integer(int)型別的方法，都是基於parseInt()方法實現的。

public static Integer valueOf(String s, int radix) throws NumberFormatException {
    return Integer.valueOf(parseInt(s, radix));
}
複製程式碼

decode(String)

將字串解碼為int，接受入參為以"0x"/"0X"/"#"打頭的十六進位制、以"0"打頭的八進位制，當然還有十進位制的字串。

    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)) { // 16進位制
            index += 2;
            radix = 16;
        }
        else if (nm.startsWith("#", index)) { // 16進位制
            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;
    }
複製程式碼

呼叫demo：

Integer.decode("0Xffff"); // 輸出65535
Integer.decode("0xffff"); // 輸出65535
Integer.decode("#ffff"); // 輸出65535
Integer.decode("077777777"); // 輸出16777215
Integer.decode("-1234"); // 輸出-1234
Integer.decode("+1234"); // 輸出1234
Integer.decode("0888"); // 異常
Integer.decode(""); // 異常
Integer.decode("aa"); // 異常
複製程式碼

相關文章