分享不易，喜歡請(qǐng)點(diǎn)贊支持，謝謝

JDK源碼精讀匯總帖

類(lèi)聲明

public final class Integer extends Number implements Comparable<Integer> {}

public abstract class Number implements java.io.Serializable {}

• 抽象類(lèi) Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 類(lèi)的超類(lèi)。
• Number 的子類(lèi)必須提供將表示的數(shù)值轉(zhuǎn)換為 byte、double、float、int、long 和 short 的方法。
• Integer中對(duì)應(yīng)的方法就是類(lèi)型轉(zhuǎn)換，將int轉(zhuǎn)換成byte、double、float、long 和 short 類(lèi)型。

compareTo

? 實(shí)現(xiàn)了Comparable，看看對(duì)應(yīng)的方法，很好理解

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

/**
 * jdk1.7之后單獨(dú)抽取出來(lái)的static方法，可以作為工具方法用于比較兩個(gè)整數(shù)
 */
public static int compare(int x, int y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

toString(int)

看看非常常用的toString方法

public static String toString(int i) {
    // 如果是Integer的最小值，直接返回字符串"-2147483648"
    if (i == Integer.MIN_VALUE)
        return "-2147483648";
    // 計(jì)算形參i的位數(shù)，負(fù)數(shù)的話，size要比數(shù)字本身多1，用來(lái)存儲(chǔ)負(fù)號(hào)(-)
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    // 構(gòu)造一個(gè)用于存儲(chǔ)數(shù)字的字符數(shù)組
    char[] buf = new char[size];
    // 填充字符數(shù)組
    getChars(i, size, buf);
    return new String(buf, true);
}

先看看stringSize方法，這個(gè)方法返回的是形參i的位數(shù)

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

// 要求形參x為正數(shù)
static int stringSize(int x) {
    // 一個(gè)個(gè)和sizeTable比較，到第i個(gè)數(shù)代表x由(i+1)個(gè)數(shù)字組成
    for (int i=0; ; i++)
        if (x <= sizeTable[i])
            return i+1;
}

再看看getChars方法，這個(gè)方法就是將組成形成i的每一個(gè)數(shù)字，填充到buf數(shù)組里。在看getChars這個(gè)方法之前可以先思考一下，怎么樣獲取形參i的每個(gè)位置上的數(shù)字呢？其實(shí)就是循環(huán)：①每次除以10求余(%)，得到的就是個(gè)位上的數(shù)字；②然后再將形參i除以10，整數(shù)相除，尾數(shù)(即前面的余數(shù))就會(huì)被丟棄；③重復(fù)①②直到形參i變成0。如12，第一次循環(huán)：除以10求余得到2，就是個(gè)位數(shù)上的數(shù)字是2，然后除以10，得到1，個(gè)位數(shù)上的2就被丟棄了，第二次循環(huán)：除10求余得到1，然后除以10得到0，于是分別得到了2和1，循環(huán)結(jié)束了。用代碼來(lái)看的話就是：

while (true) {
    r = i % 10;
    i /= 10;
    // 偽代碼↓
    // 第n次循環(huán)，將r加入到buf的倒數(shù)第n位上
    if (i == 0) break;

以上只考慮了正數(shù)的情況，對(duì)于負(fù)數(shù)的情況，只要再循環(huán)結(jié)束后，在buf的第0個(gè)位置加上一個(gè)'-'即可，完整代碼如下：

static void myGetChars(int i, int index, char[] buf) {
    int charPos = index;// 用來(lái)記錄buf每次可插入的尾部
    char sign = 0;// 是否為負(fù)數(shù)的標(biāo)記
    if (i < 0) {
        sign = '-';
        i = -i;// 當(dāng)成正數(shù)處理
    }        
    while (true) {
        int r = i % 10;
        i /= 10;
        buf [--charPos] = digits [r];// 將數(shù)字r轉(zhuǎn)成字符'r'，然后添加到buf的可插入尾部
        if (i == 0) break;
    }
    if (sign != 0) {
        buf [--charPos] = sign;
    }
}

看樣子好像實(shí)現(xiàn)了getChars的功能，但是jdk里面是不是這么做的呢？答案是：no!看看源碼：

static void getChars(int i, int index, char[] buf) {
    int q, r;// r為余數(shù)，就是每次被插入到buf的數(shù)
    int charPos = index;// buf可插入尾部
    char sign = 0;

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

    // i >= 65536時(shí)
    // 每次迭代向buf插入2個(gè)數(shù)字，即i的最后兩位，目的應(yīng)該是加快迭代速度
    while (i >= 65536) {
        q = i / 100;
        // really: r = i - (q * 100);
        // 本質(zhì)就是r = i - (q * 100)
        // q << 6 = 2^6 = 64
        // q << 5 = 2^5 = 32
        // q << 2 = 2^2 = 4
        // i - q * 100 得到的r就是i的末尾2位數(shù)，本質(zhì)是i%100，應(yīng)該是乘法運(yùn)算速度大于除法，大于求余，但是減法的速度應(yīng)該也不算快
        r = i - ((q << 6) + (q << 5) + (q << 2));
        i = q;
        // 插入r的個(gè)位數(shù)
        buf [--charPos] = DigitOnes[r];
        // 插入r的十位數(shù)
        buf [--charPos] = DigitTens[r];
    }

    // Fall thru to fast mode for smaller numbers
    // assert(i <= 65536, i);
    for (;;) {
        // 這里本質(zhì)就是i/10，
        q = (i * 52429) >>> (16+3);
        r = i - ((q << 3) + (q << 1));  // 本質(zhì)就是 r = i-(q*10)
        buf [--charPos] = digits [r];// 將數(shù)字r轉(zhuǎn)成字符'r'，然后添加到buf的可插入尾部
        i = q;
        if (i == 0) break;
    }
    if (sign != 0) {// 如果是負(fù)數(shù)，再插入'-'
        buf [--charPos] = sign;
    }
}

這里有幾個(gè)比較有意思的地方：

• 首先是分段來(lái)獲取字符，分成>=65535和<65535兩段，大于等于65535的部分，每次迭代獲取兩個(gè)字符，這里有個(gè)疑問(wèn)的地方是，為什么不分成>=10和<10兩部分呢，難道是后面這一小段代碼的執(zhí)行速度比較快？
• 其次是<65535這部分，對(duì)于q = (i * 52429) >>> (16+3);,這個(gè)代碼等價(jià)于q = i / 10;，應(yīng)該是ALU執(zhí)行乘法和移位運(yùn)算的速度快過(guò)除法的運(yùn)算速度。但是為什么是52429和2^19 (2的19次方，無(wú)符號(hào)右移19位相當(dāng)于除以2的19次方)，這是出于精度同時(shí)不會(huì)溢出這兩方面考慮的。首先說(shuō)精度方面，(double)52429/524288=0.100000381469，這個(gè)精度完全可以保證求出i的十分之一，比如選了一個(gè)精度不夠的，求出值為0.103，那么如果i是999，999*0.103=102,并不是999的十分之一99；另外一方面，65536=2^16，52429<65536，所以i * 52429 < 2^32，不會(huì)溢出，至于i * 52429 會(huì)導(dǎo)致結(jié)果變成負(fù)數(shù)的問(wèn)題，這只是中間結(jié)果，無(wú)符號(hào)右移19位之后，高位全部補(bǔ)0，結(jié)果q還是正數(shù)。
  以上可以看出，jdk還是蠻嚴(yán)謹(jǐn)?shù)模瑸榱诵室彩瞧戳恕?/li>
• 但實(shí)際測(cè)試的結(jié)果感覺(jué)運(yùn)算效率并沒(méi)有很大提高，可能是以前的ALU沒(méi)有現(xiàn)在的先進(jìn)。

toString(int, int)

? 接下來(lái)看看toString(int i, int radix)，這個(gè)方法主要是將形參i轉(zhuǎn)成radix進(jìn)制的數(shù)

public static String toString(int i, int radix) {
    // 如果小于2進(jìn)制或大于36進(jìn)制，當(dāng)成10進(jìn)制處理
    if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
        radix = 10;

    /* Use the faster version */
    // 10進(jìn)制數(shù)，直接使用更快的版本
    if (radix == 10) {
        return toString(i);
    }

    // Integer最多占用33位，數(shù)字32位，符號(hào)1位
    char buf[] = new char[33];
    boolean negative = (i < 0);// 判斷是否為負(fù)數(shù)，后面i被當(dāng)成負(fù)數(shù)來(lái)統(tǒng)一處理
    int charPos = 32;// buf最末尾的索引，從32開(kāi)始

    // 如果i是正數(shù)，取反，當(dāng)成負(fù)數(shù)處理
    if (!negative) {
        i = -i;
    }

    // i%radix的余數(shù)的絕對(duì)值放到buf當(dāng)前尾部(charPos)位置
    while (i <= -radix) {
        buf[charPos--] = digits[-(i % radix)];
        i = i / radix;
    }
    buf[charPos] = digits[-i];

    // 如果i是負(fù)數(shù)，加上'-'
    if (negative) {
        buf[--charPos] = '-';
    }
    // 返回字符串，從buf的charPos位置開(kāi)始截取，長(zhǎng)度33-charPos，正好是最后一個(gè)位置，索引下標(biāo)為32
    return new String(buf, charPos, (33 - charPos));
}

toString()

? 無(wú)參的toString就沒(méi)什么難度了，就是把Integer封裝的value轉(zhuǎn)成字符串

public String toString() {
    return toString(value);
}

toHexString(int)

? 接下來(lái)看看幾個(gè)無(wú)符號(hào)進(jìn)制的轉(zhuǎn)換

public static String toHexString(int i) {
    return toUnsignedString(i, 4);
}
public static String toOctalString(int i) {
    return toUnsignedString(i, 3);
}
public static String toBinaryString(int i) {
    return toUnsignedString(i, 1);
}
/**
 * 本質(zhì)上就是理解這個(gè)方法
 * 因?yàn)槭菬o(wú)符號(hào)，所以所有數(shù)字其實(shí)都可以想象成二進(jìn)制的情況，如17則是0000 0000 0000 0000 0000 0001 0001 0001,-17則是1111 1111 1111 1111 1111 1111 1110 1111
 */
private static String toUnsignedString(int i, int shift) {
    // 無(wú)符號(hào)數(shù)，只需存32位即可
    char[] buf = new char[32];
    // 可插入的尾部位置
    int charPos = 32;
    // 進(jìn)制
    int radix = 1 << shift;
    // 類(lèi)似掩碼的作用，二進(jìn)制是對(duì)應(yīng)的是0001,八進(jìn)制對(duì)應(yīng)0111，十六進(jìn)制對(duì)應(yīng)1111
    int mask = radix - 1;
    do {
        // 關(guān)鍵理解i & mask，整個(gè)過(guò)程就像手工轉(zhuǎn)換進(jìn)制一樣，先得到二進(jìn)制，然后每幾位一組轉(zhuǎn)換，如0001 0001轉(zhuǎn)成8進(jìn)制，每3位一組：00 010 001，然后得到0 2 1，所以17的8進(jìn)制表示就是21，i & mask的過(guò)程就像分組，每次迭代將mask對(duì)應(yīng)的位數(shù)得到，再利用digits轉(zhuǎn)換成對(duì)應(yīng)的字符
        buf[--charPos] = digits[i & mask];
        i >>>= shift;
    } while (i != 0);

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

演示一下i & mask的過(guò)程：

• i=17,mask=7，則相當(dāng)于0001 0001 & 0111 得到001,digit[1]
  =1,第二次迭代i=000 010,000 010 & 0111得到010,digit[2]=2,迭代結(jié)束，buf=21。
• i=17,mask-15，則相當(dāng)于0001 0001 & 1111 得到0001,digit[1]
  =1,第二次迭代i=0001,0001 & 1111得到0001,digit[1]=1,迭代結(jié)束,buf=11。

parseInt(String, int)

? 接著看parseInt方法，進(jìn)制轉(zhuǎn)換的公式：a * radix^0 + b * radix^1 + c * radix^2 + ... + xx * radix^(n-1)

/**
 * 整個(gè)過(guò)程的關(guān)鍵點(diǎn)都在判斷下一次迭代會(huì)不會(huì)導(dǎo)致溢出
 * 
 */
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.
     */

    // 下面都是判斷s不能為空，進(jìn)制必須在[2, 36]，可以看到j(luò)dk的源碼處理也有問(wèn)題，之前進(jìn)制轉(zhuǎn)換的，不在[2, 36]之間就當(dāng)成10進(jìn)制處理，現(xiàn)在是拋異常，規(guī)則不一樣
    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");
    }

    // 當(dāng)前的轉(zhuǎn)換結(jié)果
    int result = 0;
    // 后面的處理都基于負(fù)數(shù)處理，一方面是統(tǒng)一規(guī)則，另外Integer.MIN_VALUE的絕對(duì)值比較大
    boolean negative = false;
    int i = 0, len = s.length();
    // 后面兩個(gè)參數(shù)限制溢出的作用
    int limit = -Integer.MAX_VALUE;
    // 界定溢出，具體看下面的注釋
    int multmin;
    // 通過(guò)Character#digit轉(zhuǎn)換過(guò)來(lái)的數(shù)值
    int digit;

    if (len > 0) {
        // 處理第一個(gè)字符
        char firstChar = s.charAt(0);
        if (firstChar < '0') { // Possible leading "+" or "-"
            if (firstChar == '-') {
                negative = true;
                // 如果是負(fù)數(shù)，溢出標(biāo)志變成Integer.MIN_VALUE
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+')
                throw NumberFormatException.forInputString(s);

            if (len == 1) // Cannot have lone "+" or "-"
                throw NumberFormatException.forInputString(s);
            i++;
        }
        // 界定是否溢出的標(biāo)志，假設(shè)10進(jìn)制最大是211，則multmin = 211 / 10 = 21，假設(shè)現(xiàn)在result為30，那么下一次迭代result *= radix肯定會(huì)大于211，溢出了。
        multmin = limit / radix;
        while (i < len) {
            // Accumulating negatively avoids surprises near MAX_VALUE
            // 轉(zhuǎn)換函數(shù)，具體在Character類(lèi)了解
            digit = Character.digit(s.charAt(i++),radix);
            if (digit < 0) {
                throw NumberFormatException.forInputString(s);
            }
            // 因?yàn)槭钱?dāng)成負(fù)數(shù)(limit是負(fù)數(shù))處理，相當(dāng)于正數(shù)的result > multmin
            if (result < multmin) {
                throw NumberFormatException.forInputString(s);
            }
            result *= radix;// 迭代，就是套公式a * radix^(n-1)的過(guò)程
            // 同樣是判斷溢出的過(guò)程，繼續(xù)上面的分析，result現(xiàn)在是210，如果digit是2，則轉(zhuǎn)換后的result = 212，也是溢出了。
            if (result < limit + digit) {
                throw NumberFormatException.forInputString(s);
            }
            result -= digit;// 公式里相加的過(guò)程，負(fù)數(shù)的話就是減
        }
    } else {
        throw NumberFormatException.forInputString(s);
    }
    return negative ? result : -result;
}
// 這個(gè)就是調(diào)用上面的方法
public static int parseInt(String s) throws NumberFormatException {
  return parseInt(s,10);
}

valueOf()

? 接著看看valueOf方法，在看valueOf方法之前，需要先看看IntegerCache，顧名思義，這個(gè)是整數(shù)的緩存，默認(rèn)情況下，IntegetCache會(huì)緩存[-128, 127]的所有實(shí)例，所以正常情況下，在這兩個(gè)值范圍內(nèi)的對(duì)象都是相等的(==返回true)，因?yàn)樗鼈円玫氖峭粔K內(nèi)存上的對(duì)象，有點(diǎn)單例的意思，當(dāng)然可以通過(guò)啟動(dòng)參數(shù)-XX:AutoBoxCacheMax=size來(lái)修改緩存的內(nèi)容(size必須大于127，否則當(dāng)成127)來(lái)讓jvm緩存[-size-1, size]的對(duì)象。看看代碼：

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);// 如果配置的值比127小，緩存上界還是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;
            // 對(duì)象一個(gè)個(gè)緩存起來(lái)，用cache數(shù)組保存
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }

具體看看valueOf方法

// 調(diào)用的parseInt方法以及分析過(guò)
public static Integer valueOf(String s, int radix) throws NumberFormatException {
  return Integer.valueOf(parseInt(s,radix));
}
public static Integer valueOf(String s) throws NumberFormatException {
  return Integer.valueOf(parseInt(s, 10));
}
public static Integer valueOf(int i) {
  assert IntegerCache.high >= 127;// 防止IntegetCache函數(shù)上界不是127
  // 在[IntegetCache.low, Integer.high]直接的直接從緩存中返回
  if (i >= IntegerCache.low && i <= IntegerCache.high)
    return IntegerCache.cache[i + (-IntegerCache.low)];
  return new Integer(i);// 否則新建一個(gè)實(shí)例
}

分享不易，轉(zhuǎn)載請(qǐng)注明出處

java.lang.Integer源碼精讀(一)
地址：http://www.lxweimin.com/p/02c1d9092347