天道不一定酬所有勤
但是,天道只酬勤

Java 源碼學習系列(三)——Integer

Integer 類在對象中包裝了一個基本類型 int 的值。Integer 類型的對象包含一個 int 類型的字段。

此外,該類提供了多個方法,能在 int 類型和 String 類型之間互相轉換,還提供了處理 int 類型時非常有用的其他一些常量和方法。

類定義

public final class Integer extends Number implements Comparable<Integer>

從類定義中我們可以知道以下幾點:

1、Integer類不能被繼承

2、Integer類實現了Comparable接口,所以可以用compareTo進行比較并且Integer對象只能和Integer類型的對象進行比較,不能和其他類型比較(至少調用compareTo方法無法比較)。

3、Integer繼承了Number類,所以該類可以調用longValue、floatValue、doubleValue等系列方法返回對應的類型的值。

屬性

一、私有屬性

Integer類中定義了以下幾個私有屬性:

private final int value;
private static final long serialVersionUID = 1360826667806852920L;

serialVersionUID和序列化有關。String的源碼學習中有介紹,這里不再贅述。

還有一個私有屬性——value屬性就是Integer對象中真正保存int值的。

當我們使用new Integer(10)創建一個Integer對象的時候,就會用以下形式給value賦值。還有其他的構造函數在后面會講。

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

這里我們討論一下Interger對象的可變性。從value的定義形式中可以看出value被定義成final類型。也就說明,一旦一個Integer對象被初始化之后,就無法再改變value的值。那么這里就深入討論一下以下代碼的邏輯:

/**
 * Created by hollis on 16/1/22.
 */
public class IntegerTest {
    public static void main(String[] args) {
        Integer i = new Integer(10);
        i = 5;
    }
}

在以上代碼中,首先調用構造函數new一個Integer對象,給私有屬性value賦值,這時value=10,接下來使用i=5的形式試圖改變i的值。有一點開發經驗的同學都知道,這個時候如果使用變量i,那么它的值一定是5,那么i=5這個賦值操作到底做了什么呢?到底是如何改變i的值的呢?是改變了原有對象i中value的值還是重新創建了一個新的Integer對象呢?

我們將上面的代碼進行反編譯,反編譯之后的代碼如下:

public class IntegerTest
{

    public IntegerTest()
    {
    }

    public static void main(String args[])
    {
        Integer i = new Integer(10);
        i = Integer.valueOf(5);
    }
}

通過看反編譯之后的代碼我們發現,編譯器會把i=5轉成i = Integer.valueOf(5);這里先直接給出結論,i=5操作并沒有改變使用Integer i = new Integer(10);創建出來的i中的value屬性的值。要么是直接返回一個已有對象,要么新建一個對象。這里的具體實現細節在后面講解valueOf方法的時候給出。

二、公共屬性

//值為 (-(2的31次方)) 的常量,它表示 int 類型能夠表示的最小值。
public static final int   MIN_VALUE = 0x80000000;
//值為 ((2的31次方)-1) 的常量,它表示 int 類型能夠表示的最大值。
public static final int   MAX_VALUE = 0x7fffffff;   
//表示基本類型 int 的 Class 實例。
public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");
//用來以二進制補碼形式表示 int 值的比特位數。
public static final int SIZE = 32;
//用來以二進制補碼形式表示 int 值的字節數。1.8以后才有
public static final int BYTES = SIZE / Byte.SIZE;

以上屬性可直接使用,因為他們已經定義成publis static fianl能用的時候盡量使用他們,這樣不僅能使代碼有很好的可讀性,也能提高性能節省資源。

方法

構造方法

Integer提供了兩個構造方法:

//構造一個新分配的 Integer 對象,它表示指定的 int 值。
public Integer(int value) {
    this.value = value;
}

//構造一個新分配的 Integer 對象,它表示 String 參數所指示的 int 值。
public Integer(String s) throws NumberFormatException {
    this.value = parseInt(s, 10);
}

從構造方法中我們可以知道,初始化一個Integer對象的時候只能創建一個十進制的整數。

Integer valueOf(int i)方法

前面說到Integer中私有屬性value的時候提到

Integer i = new Integer(10);
i = 5;

其中i=5操作時,編譯器會轉成i = Integer.valueOf(5);執行。那么這里就解釋一下valueOf(int i)方法是如何給變量賦值的。

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

以上是valueOf方法的實現細節。通常情況下,IntegerCache.low=-128,IntegerCache.high=127(除非顯示聲明java.lang.Integer.IntegerCache.high的值),Integer中有一段動態代碼塊,該部分內容會在Integer類被加載的時候就執行。

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;
    }

也就是說,當Integer被加載時,就新建了-128到127的所有數字并存放在Integer數組cache中。

再回到valueOf代碼,可以得出結論。當調用valueOf方法(包括后面會提到的重載的參數類型包含String的valueOf方法)時,如果參數的值在-127到128之間,則直接從緩存中返回一個已經存在的對象。如果參數的值不在這個范圍內,則new一個Integer對象返回。

所以,當把一個int變量轉成Integer的時候(或者新建一個Integer的時候),建議使用valueOf方法來代替構造函數?;蛘咧苯邮褂?code>Integer i = 100;編譯器會轉成Integer s = Integer.valueOf(10000);

String轉成Integer(int)的方法

Integer getInteger(String nm)
Integer getInteger(String nm, int val)
Integer getInteger(String nm, Integer val)
Integer decode(String nm)
Integer valueOf(String s)
Integer valueOf(String s, int radix)
int parseUnsignedInt(String s)
int parseUnsignedInt(String s, int radix)
int parseInt(String s)
int parseInt(String s, int radix)

以上所有方法都能實現將String類型的值轉成Integer(int)類型(如果 String 不包含可解析整數將拋出NumberFormatException)

可以說,所有將String轉成Integer的方法都是基于parseInt方法實現的。簡單看一下以上部分方法的調用棧。

getInteger(String nm) ---> getInteger(nm, null);--->Integer.decode()--->Integer.valueOf()--->parseInt()

getInteger

確定具有指定名稱的系統屬性的整數值。 第一個參數被視為系統屬性的名稱。通過 System.getProperty(java.lang.String) 方法可以訪問系統屬性。然后,將該屬性的字符串值解釋為一個整數值,并返回表示該值的 Integer 對象。使用 getProperty 的定義可以找到可能出現的數字格式的詳細信息。其中參數nm應該在System的props中可以找到。這個方法在日常編碼中很好是用到。在代碼中可以用以下形式使用該方法:

Properties props = System.getProperties();
props.put("hollis.integer.test.key","10000");
Integer i = Integer.getInteger("hollis.integer.test.key");
System.out.println(i);
//輸出 10000

另外兩個方法

getInteger(String nm,int val)
getInteger(String nm, Integer val)

第二個參數是默認值。如果未具有指定名稱的屬性,或者屬性的數字格式不正確,或者指定名稱為空或 null,則返回默認值。

getInteger的具體實現細節如下:

public static Integer getInteger(String nm, Integer val) {
        String v = null;
        try {
            v = System.getProperty(nm);
        } catch (IllegalArgumentException | NullPointerException e) {
        }
        if (v != null) {
            try {
                return Integer.decode(v);
            } catch (NumberFormatException e) {
            }
        }
        return val;
    }

先按照nm作為key從系統配置中取出值,然后調用Integer.decode方法將其轉換成整數并返回。

decode

public static Integer decode(String nm) throws NumberFormatException

該方法的作用是將 String 解碼為 Integer。接受十進制、十六進制和八進制數字。

根據要解碼的 String(mn)的形式轉成不同進制的數字。 mn由三部分組成:符號、基數說明符和字符序列。 —0X123-是符號位,0X是基數說明符(0表示八進制,0x,0X,#表示十六進制,什么都不寫則表示十進制),123是數字字符序列。

使用例子舉例如下:

Integer DecimalI = Integer.decode("+10");
Integer OctI = Integer.decode("-010");
Integer HexI = Integer.decode("-0x10");
Integer HexI1 = Integer.decode("#10");
System.out.println(DecimalI);
System.out.println(OctI);
System.out.println(HexI);
System.out.println(HexI1);
//10 -8 -16 16

decode方法的具體實現也比較簡單,首先就是判斷String類型的參數mn是否以(+/—)符號開頭。然后再依次判斷是否以”0x”、“#”、“0”開頭,確定基數說明符的值。然后將字符串mn進行截取,只保留其中純數字部分。在用截取后的純數字和基數調用valueOf(String s, int radix)方法并返回其值。

valueOf

public static Integer valueOf(String s) throws NumberFormatException 
public static int parseInt(String s, int radix) throws NumberFormatException

返回一個 Integer 對象。如果指定第二個參數radix,將第一個參數解釋為用第二個參數指定的基數表示的有符號整數。如果沒指定則按照十進制進行處理。

該方法實現非常簡單:

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

主要用到了兩個方法,parseInt(String s, int radix)valueOf(int i)方法。前面已經講過valueOf方法會檢查參數內容是否在-127到128之間,如果是則直接返回。否則才會新建一個對象。

parseInt

public static int parseInt(String s) throws NumberFormatException {
    return parseInt(s,10);
}

public static int parseInt(String s, int radix) throws NumberFormatException

使用第二個參數指定的基數(如果沒指定,則按照十進制處理),將字符串參數解析為有符號的整數。除了第一個字符可以是用來表示負值的 ASCII 減號 ‘-‘ (‘\u002D’)外,字符串中的字符必須都是指定基數的數字(通過 Character.digit(char, int) 是否返回一個負值確定)。返回得到的整數值。

如果發生以下任意一種情況,則拋出一個 NumberFormatException 類型的異常:

第一個參數為 null 或一個長度為零的字符串。

基數小于 Character.MIN_RADIX 或者大于 Character.MAX_RADIX。

假如字符串的長度超過 1,那么除了第一個字符可以是減號 ‘-‘ (‘u002D’) 外,字符串中存在任意不是由指定基數的數字表示的字符.

字符串表示的值不是 int 類型的值。

示例:

parseInt("0", 10) 返回 0
parseInt("473", 10) 返回 473
parseInt("-0", 10) 返回 0
parseInt("-FF", 16) 返回 -255
parseInt("1100110", 2) 返回 102
parseInt("2147483647", 10) 返回 2147483647
parseInt("-2147483648", 10) 返回 -2147483648
parseInt("2147483648", 10) 拋出 NumberFormatException
parseInt("99", 8) 拋出 NumberFormatException
parseInt("Hollis", 10) 拋出 NumberFormatException
parseInt("Hollis", 27) 拋出 NumberFormatException
parseInt("ADMIN", 27) 返回 5586836 

該方法的具體實現方式也比較簡單,主要邏輯代碼(省略部分參數校驗)如下:

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;
}

主要思想其實也很好理解。

“12345”按照十進制轉成12345的方法其實就是以下方式: ((1*10)+2)*10)+3)*10+4)*10+5 具體的如何依次取出“12345”中的每一個字符并將起轉成不同進制int類型則是Character.digit方法實現的,這里就不深入講解了。

總結

上面列舉了很多能夠將String轉成Integer的方法。那么他們之間有哪些區別,又該如何選擇呢?

parseInt方法返回的是基本類型int

其他的方法返回的是Integer

valueOf(String)方法會調用valueOf(int)方法。

如果只需要返回一個基本類型,而不需要一個對象,可以直接使用Integert.parseInt("123");

如果需要一個對象,那么建議使用valueOf(),因為該方法可以借助緩存帶來的好處。

如果和進制有關,那么就是用decode方法。

如果是從系統配置中取值,那么就是用getInteger

int轉成String的方法

String  toString()
static String   toString(int i)
static String   toString(int i, int radix)
static String   toBinaryString(int i)
static String   toHexString(int i)
static String   toOctalString(int i)
static String   toUnsignedString(int i)
static String   toUnsignedString(int i, int radix)

直接看toString方法,toString方法的定義比較簡單,就是把一個int類型的數字轉換成字符串類型,但是這個方法的實現調用了一系列方法,通過閱讀這個方法,你就會對sun公司的程序員產生油然的敬佩。

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

我們把toString方法分解為以下幾個片段:

片段一:

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

片段一

if (i == Integer.MIN_VALUE)
        return "-2147483648";

這里先對i的值做檢驗,如果等于Int能表示的最小值,則直接返回最小值的字符串形式。那么為什么-2147483648要特殊處理呢?請看代碼片段二的分析。

片段二

int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
char[] buf = new char[size];

這段代碼的主要目的是體取出整數i的位數,并創建一個字符數組。 其中提取I的位數使用stringSize方法,這個方法實現如下:

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

// Requires positive x
static int stringSize(int x) {
    for (int i=0; ; i++)
        if (x <= sizeTable[i])
            return i+1;
}

該方法要求傳入一個正整數,如果傳入的數字x的值是10000,那么因為他大于9,99,999,9999,小于99999.所以他會返回99999在整型數組sizeTable中的下標”4″+1 = 5。我們看10000這個數字的位數也確實是5。所以,就實現了返回一個正整數的位數。

設置size時,當i<0的時候返回的size數組在stringSize方法的基礎上+1的目的是這一位用來存儲負號。

由于stringSize方法要求傳入一個正整數,所以代碼片段二在調用該方法時需要將負數轉成正數傳入。代碼片段一中,將-2147483648的值直接返回的原因就是整數最大只能表示2147483647,無法將stringSize(-i)中的i賦值成-2147483648。

getSize使用了的體系結構知識:

1.局部性原理之空間局部性:sizeTable為數組,存儲在相鄰的位置,cpu一次加載一個塊數據數據到cache中(多個數組數據),此后訪問sizeTable 不需要訪問內存。

2.基于范圍的查找,是很實用的設計技術

片段三

getChars(i, size, buf);

那么接下來就深入理解一下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;
    }

     // 每次循環過后,都會將i中的走后兩位保存到字符數組buf中的最后兩位中,讀者可以將數字i設置為12345678測試一下, 
     //第一次循環結束之后,buf[7] = 8,buf[6]=7。第二次循環結束之后,buf[5] = 6,buf[4] = 5。
    while (i >= 65536) {
        q = i / 100;
    // really: r = i - (q * 100);
        r = i - ((q << 6) + (q << 5) + (q << 2));
        i = q;
        //取DigitOnes[r]的目的其實取數字r%10的結果
        buf [--charPos] = DigitOnes[r];
        //取DigitTens[r]的目的其實是取數字r/10的結果
        buf [--charPos] = DigitTens[r];
    }

    // Fall thru to fast mode for smaller numbers
    // assert(i <= 65536, i);
    //循環將其他數字存入字符數組中空余位置
    for (;;) {
          //這里其實就是除以10。取數52429和16+3的原因在后文分析。
        q = (i * 52429) >>> (16+3);
        // r = i-(q*10) ...
        r = i - ((q << 3) + (q << 1));   
        //將數字i的最后一位存入字符數組,
        //還是12345678那個例子,這個for循環第一次結束后,buf[3]=4。
        buf [--charPos] = digits [r];
        i = q;
        //for循環結束后,buf內容為“12345678”;
        if (i == 0) break;
    }
    if (sign != 0) {
        buf [--charPos] = sign;
    }
}

//其中用到的幾個數組

//100以內的數字除以10的結果(取整),
//比如取DigitTens[78],返回的是數字7
//只要是70-79的數字,返回的都是7,依次類推,所以總結出規律,其實就是返回的對應數字除10取整的結果。
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',
    } ;

 //100以內的數字對10取模的結果,
//比如取DigitTens[78],返回的8
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',
    } ;
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'
};

接下來分析兩個問題:

問題一、為什么在getChars方法中,將整型數字寫入到字符數組的過程中為什么按照數字65536分成了兩部分呢?這個65535是怎么來的?

部分一

while (i >= num1) {
        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 * num2) >>> (num3);
        r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...
        buf [--charPos] = digits [r];
        i = q;
        if (i == 0) break;
    }

使用num1,num2,num3三個變量代替源代碼中的數字,便于后面分析使用。

問題二、在上面兩段代碼的部分二中,在對i進行除十操作的過程中為什么選擇先乘以52429在向右移位19位。其中52429和19是怎么來的?

解答

回答上面兩個問題之前,首先要明確兩點:

移位的效率比直接乘除的效率要高

乘法的效率比除法的效率要高

先理解以下代碼:

r = i - ((q << 6) + (q << 5) + (q << 2));表示的其實是r = i - (q * 100);,i-q*2^6 - q*2^5 - q*2^2 = i-64q-32q-4q = i-100q。

q = (i * num2) >>> (num3);中,>>>表示無符號向右移位。代表的意義就是除以2^num3。 所以q = (i * 52429) >>> (16+3); 可以理解為:q = (i * 52429) / 524288;,那么就相當于 q= i * 0.1也就是q=i/10,這樣通過乘法和向右以為的組合的形式代替了除法,能提高效率。

再來回答上面兩個問題中,部分一和部分二中最大的區別就是部分一代碼使用了除法,第二部分只使用了乘法和移位。因為乘法和移位的效率都要比除法高,所以第二部分單獨使用了乘法加移位的方式來提高效率。那么為什么不都使用乘法加移位的形式呢?為什么大于num1(65536)的數字要使用除法呢?原因是int型變量最大不能超過(2^31-1)。如果使用一個太大的數字進行乘法加移位運算很容易導致溢出。那么為什么是65536這個數字呢?第二階段用到的乘法的數字和移位的位數又是怎么來的呢?

我們再回答第二個問題。

既然我們要使用q = (i * num2) >>> (num3);的形式使用乘法和移位代替除法,那么n和m就要有這樣的關系:

num2= (2^num3 /10 +1)

只有這樣才能保證(i * num2) >>> (num3)結果接近于0.1。

那么52429這個數是怎么來的呢?來看以下數據:

2^10=1024, 103/1024=0.1005859375
2^11=2048, 205/2048=0.10009765625
2^12=4096, 410/4096=0.10009765625
2^13=8192, 820/8192=0.10009765625
2^14=16384, 1639/16384=0.10003662109375
2^15=32768, 3277/32768=0.100006103515625
2^16=65536, 6554/65536=0.100006103515625
2^17=131072, 13108/131072=0.100006103515625
2^18=262144, 26215/262144=0.10000228881835938
2^19=524288, 52429/524288=0.10000038146972656
2^20=1048576, 104858/1048576=0.1000003815
2^21=2097152, 209716/2097152 = 0.1000003815
2^22= 4194304, 419431/4194304= 0.1000001431

超過22的數字我就不列舉了,因為如果num3越大,就會要求i比較小,因為必須保證(i * num2) >>> (num3)的過程不會因為溢出而導致數據不準確。那么是怎么敲定num1=65536,num2= 524288, num3=19的呢? 這三個數字之間是有這樣一個操作的:

(num1* num2)>>> num3

因為要保證該操作不能因為溢出導致數據不準確,所以num1和num2就相互約束。兩個數的乘積是有一定范圍的,不成超過這個范圍,所以,num1增大,num2就要隨之減小。

我覺得有以下幾個原因:

1.52429/524288=0.10000038146972656精度足夠高。

2.下一個精度較高的num2和num3的組合是419431和22。2^31/2^22 = 2^9 = 512。512這個數字實在是太小了。65536正好是2^16,一個整數占4個字節。65536正好占了2個字節,選定這樣一個數字有利于CPU訪問數據。

不知道有沒有人發現,其實65536* 52429是超過了int的最大值的,一旦超過就要溢出,那么為什么還能保證(num1* num2)>>> num3能得到正確的結果呢?

這和>>>有關,因為>>>表示無符號右移,他會在忽略符號位,空位都以0補齊。

一個有符號的整數能表示的范圍是-2147483648至2147483647,但是無符號的整數能表示的范圍就是0-4,294,967,296(2^32),所以,只要保證num2*num3的值不超過2^32次方就可以了。65536是2^16,52429正好小于2^16,所以,他們的乘積在無符號向右移位就能保證數字的準確性。

getChars使用了的體系結構知識:

1.乘法比除法高效:q = ( i * 52429) >>> (16+3); => 約等于q0.1,但i52429是整數乘法器,結合位移避免除法。

2.重復利用計算結果:在獲取r(i%100)時,充分利用了除法的結果,結合位移避免重復計算。

3.位移比乘法高效:r = i – (( q << 6) + ( q << 5) + ( q << 2)); = >等價于r = i – (q * 100);

4.局部性原理之空間局部性

(1).buf[–charPos] =DigitOnes[r];buf[–charPos] =DigitTens[r];通過查找數組,實現快速訪問,避免除法計算

(2).buf [–charPos ] = digits [ r];

片段四

return new String(buf, true);

這里用到了一個String中提供的保護類型構造函數,關于此函數請查看String源碼分析,該函數比使用其他的構造函數有更好的性能。

總結

所以,一個Integer對象有很多方法能夠將值轉成String類型。除了上面提到的一系列方法外,一般在要使用String的時候,很多人愿意使用如下形式:

Integer s = new Integer(199);
System.out.println(s + "");

老規矩,反編譯看看怎么實現的:

Integer s = new Integer(199);
System.out.println((new StringBuilder()).append(s).append("").toString());

筆者使用JMH進行了測試,結果證明方法效率更高。

compareTo方法

在看是介紹Interger的類定義的時候介紹過,Integer類實現了Comparable<Integer>接口,所以Integer對象可以和另外一個Integer對象進行比較。

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

代碼實現比較簡單,就是拿出其中的int類型的value進行比較。

實現Number的方法

int intValue();
long longValue();
float floatValue();
double doubleValue();
byte byteValue();
short shortValue();

實現如下:

public long longValue() {
    return (long)value;
}

public float floatValue() {
    return (float)value;
}

public double doubleValue() {
    return (double)value;
}

參考資料

Java? Platform, Standard Edition 8 API Specification

(全文完) 歡迎關注『Java之道』微信公眾號
贊(5)
如未加特殊說明,此網站文章均為原創,轉載必須注明出處。HollisChuang's Blog » Java 源碼學習系列(三)——Integer
分享到: 更多 (0)

評論 5

  • 昵稱 (必填)
  • 郵箱 (必填)
  • 網址
  1. #1

    將 parseInt那段,代碼片段最后有段代碼:
    parseInt(Hollis, 27) 返回 411787
    這里好像也是拋出異常:NumberFormatException,27進制的最大值應該是到26即到字母 q(Q);[/疑問]

    淩亂1955在搜狐4年前 (2016-02-20)回復
    • 是的。你說的沒錯。筆誤寫錯,已經修正: Integer.parseInt(“ADMIN”, 27) ——> 5586836

      HollisChuang4年前 (2016-02-22)回復
  2. #2

    謝謝樓主 茅塞頓開

    冰藍色狂想曲4年前 (2016-03-03)回復
  3. #3

    n和m就要有這樣的關系:num2= (2^num3 /10 +1)。
    請問這個式子中的 +1 是怎么得來的?

    Skylar1年前 (2018-12-18)回復
  4. #4

    還有一個疑問, q = (i * 52429) >>> (16+3); 這里為什么不直接用 19,而是用 16+3 代替?

    lulululbj1年前 (2019-02-22)回復

HollisChuang's Blog

聯系我關于我
大乐透复式返奖 股票配资推荐 丨找杨方配资开户 上海天天彩选4今开奖 篮球场地 打字赚钱是什么网站 股票融资如何操作 澳门百家乐代理 王中王资料精选九龙心水 股票行情在线查询 平特四连肖高手论坛 上海明星麻将最新版