Integer源码详解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    /**
     * Returns the number of one-bits in the two's complement binary
     * representation of the specified {@code int} value.  This function is
     * sometimes referred to as the <i>population count</i>.
     *
     * @return the number of one-bits in the two's complement binary
     *     representation of the specified {@code int} value.
     * @since 1.5
     */
    public static int bitCount(int i) {
        // HD, Figure 5-2
        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;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
    public static int bitCount(int i) {
        // HD, Figure 5-2
        /**
         * 每两位为一个单元，把原来单元中1的个数储存在原来的单元中
         */
        i = i - ((i >>> 1) & 0x55555555);
        /**
         *0x33333333其实就是二进制……00110011（共32位），因为上面的每两位代表1的个数，所以下面的这几行就是要把上面每两位
         * 的数字加起来，下面的这行代码可以这样理解，每4位分为一组，然后4位中的每两位相加，相加的结果在储存到这4位二进制数中，
         * i & 0x33333333表示每4位中的低2位，(i >>> 2) & 0x33333333表示每4位中的高2位，然后在相加
         */
        i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
        /**
         * 这个更好理解，i >>> 4表示往右移动了4位，然后在与i相加，相当于每8位一组，然后8位中的高4位与低4位相加储存在低4位中，
         * 然后这里在与0x0f0f0f0f进行与运算，把高4位完全置为0了，因为0x0f0f0f0f用二进制表示就是00001111000011110000111100001111，
         * 看到这里可能有些困惑，这里为什么要与0x0f0f0f0f进行与运算，因为每8位一组的话，最多也就是8，那么4位数足够了，高4位就没有必要了，
         * 如果不置为0有没有影响，其实如果1的位数极少的话是没什么影响的，但如果1的位数比较多到后面计算的结果可能就会往前进位，导致结果错误，
         * 所以这一步要进行一次与运算，那为什么上面的那行代码没有把4位一组中的高两位置0，这是因为4位一组最多有4个1，而2位二进制数最多表示3，
         * 小于4，所以不能置为0，
         *
         */
        i = (i + (i >>> 4)) & 0x0f0f0f0f;
        /**
         * 和上面类似，每16位分为一组，每组中的高8位和低8位相加，这里的代码相加的很干净，因为无论是高8位还是低8位中的前4位在上面一行中
         * 都已经置为0了，这里也可以像上面那样，加完之后在与0x00ff00ff进行与运算，但其实这里已经没有必要了，因为int类型为32位，
         * 最多也就32个1，用8位数储存足够了，所以不会超过8位，也就不用担心超过8位在往前进1位的问题了。
         */
        i = i + (i >>> 8);
        /**
         * 和上面类似，就不在详述
         */
        i = i + (i >>> 16);
        /**
         * 到最后为什么要和0x3f进行与运算，0x3f用二进制表示就是111111,因为上面两行没有进行与运算，所以前面的数据都是无效的，
         * 只有最后8位是有效的，而后8位的前两位不用说肯定为0，因为最多也就32个1，用后面6位数表示就已经足够了，所以这里与0x3f
         * 进行与运算，来计算出最终1的个数
         */
        return i & 0x3f;
    }

1
2
3
4
5
6
7
8
    public static int bitCount(int var0) {
        var0 -= var0 >>> 1 & 1431655765;
        var0 = (var0 & 858993459) + (var0 >>> 2 & 858993459);
        var0 = var0 + (var0 >>> 4) & 252645135;
        var0 += var0 >>> 8;
        var0 += var0 >>> 16;
        return var0 & 63;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    /**
     * Returns an {@code int} value with at most a single one-bit, in the
     * position of the highest-order ("leftmost") one-bit in the specified
     * {@code int} value.  Returns zero if the specified value has no
     * one-bits in its two's complement binary representation, that is, if it
     * is equal to zero.
     *
     * @return an {@code int} value with a single one-bit, in the position
     *     of the highest-order one-bit in the specified value, or zero if
     *     the specified value is itself equal to zero.
     * @since 1.5
     */
    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
2
3
4
5
6
7
8
9
10
    private static int roundUpToPowerOf2(int number) {
        // assert number >= 0 : "number must be non-negative";
        int rounded = number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (rounded = Integer.highestOneBit(number)) != 0
                    ? (Integer.bitCount(number) > 1) ? rounded << 1 : rounded
                    : 1;

        return rounded;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    /**
     * Returns the value obtained by reversing the order of the bits in the
     * two's complement binary representation of the specified {@code int}
     * value.
     *
     * @return the value obtained by reversing order of the bits in the
     *     specified {@code int} value.
     * @since 1.5
     */
    public static int reverse(int i) {
        // HD, Figure 7-1
        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;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    /**
     * Returns the value obtained by reversing the order of the bytes in the
     * two's complement representation of the specified {@code int} value.
     *
     * @return the value obtained by reversing the bytes in the specified
     *     {@code int} value.
     * @since 1.5
     */
    public static int reverseBytes(int i) {
        return ((i >>> 24)           ) |
               ((i >>   8) &   0xFF00) |
               ((i <<   8) & 0xFF0000) |
               ((i << 24));
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    /**
     * Returns the number of zero bits following the lowest-order ("rightmost")
     * one-bit in the two's complement binary representation of the specified
     * {@code int} value.  Returns 32 if the specified value has no
     * one-bits in its two's complement representation, in other words if it is
     * equal to zero.
     *
     * @return the number of zero bits following the lowest-order ("rightmost")
     *     one-bit in the two's complement binary representation of the
     *     specified {@code int} value, or 32 if the value is equal
     *     to zero.
     * @since 1.5
     */
    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);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
    public static int numberOfTrailingZeros(int i) {
        // HD, Figure 5-14
        int y;
        //等于0的时候返回32
        if (i == 0) return 32;
        //因为返回的是右边第一个1的右边的0的个数，如果不是0，则0的个数肯定不会大于31
        int n = 31;
        /**
         *  左移16位，如果y==0，说明原来i的低16位上是没有1的,只能说明高16位上有1，那么n肯定是大于或等于16。
         *  如果y！=0，说明原来i的低16位上肯定是有1，那么n就会小于16，只需要运算低16就行了，所以就把y赋值给i，
         *  同时n也要减去16，
         */
        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; }
        /**
         * (i << 1) >>> 31表示计算i的第31位上的值，i << 1表示把i的第31位变成32位，然后再无符号的右移31位，
         所以得到的结果就是i的第31位上的值，但是要记住这个i不是最初的那个i，而是运算之后的i，因为上面有赋值，
         当满足条件的时候i就会改变。这里为什么要减去第31位上的值，这是因为上面最后一行运行之前其实i已经
         判断了（16+8+4=28）位了，当上面最后一行运行之后就只剩下最后两位了，我们知道通过上面一步步的运算，
         到这里i的第32位和31位至少有1个1，不可能全是0，如果全是0只有当最初始的i为0的时候，那么这是不可能的，
         因为如果最初始的i为0，在最上面就已经被拦截了,直接返回32了。这里为什么要减去31位上的值而不是32位上的值，
         这就是算法的巧妙之处,因为这个方法返回的是右边第一个1右边0的个数，所以这里只需要判断第31位就行了，因为如果
         31位为1的话，那么32位就没他什么事了，不管他是0还是1都不会有影响，因为31位是在32位的右边（最右边是第一位，
         最左边是第32位），只需要把31位的1减掉就行了，如果31位是0，那么32位肯定为1，因为31和32位必须有一个是1，
         ，其实他这里是把代码简化了，还可以这样写,把最后一行注释掉，改为下面这样，运算结果是一样的
         // y = i << 1; if (y != 0) { n = n - 1; }
         // return n ;
         */
        return n - ((i << 1) >>> 31);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
    /**
     * Returns the number of zero bits preceding the highest-order
     * ("leftmost") one-bit in the two's complement binary representation
     * of the specified {@code int} value.  Returns 32 if the
     * specified value has no one-bits in its two's complement representation,
     * in other words if it is equal to zero.
     *
     * <p>Note that this method is closely related to the logarithm base 2.
     * For all positive {@code int} values x:
     * <ul>
     * <li>floor(log<sub>2</sub>(x)) = {@code 31 - numberOfLeadingZeros(x)}
     * <li>ceil(log<sub>2</sub>(x)) = {@code 32 - numberOfLeadingZeros(x - 1)}
     * </ul>
     *
     * @return the number of zero bits preceding the highest-order
     *     ("leftmost") one-bit in the two's complement binary representation
     *     of the specified {@code int} value, or 32 if the value
     *     is equal to zero.
     * @since 1.5
     */
    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;
    }

1
2
3
4
5
6
7
8
9
10
11
12
    /**
     * Returns the signum function of the specified {@code int} value.  (The
     * return value is -1 if the specified value is negative; 0 if the
     * specified value is zero; and 1 if the specified value is positive.)
     *
     * @return the signum function of the specified {@code int} value.
     * @since 1.5
     */
    public static int signum(int i) {
        // HD, Section 2-7
        return (i >> 31) | (-i >>> 31);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    /**
     * Returns the value obtained by rotating the two's complement binary
     * representation of the specified {@code int} value right by the
     * specified number of bits.  (Bits shifted out of the right hand, or
     * low-order, side reenter on the left, or high-order.)
     *
     * <p>Note that right rotation with a negative distance is equivalent to
     * left rotation: {@code rotateRight(val, -distance) == rotateLeft(val,
     * distance)}.  Note also that rotation by any multiple of 32 is a
     * no-op, so all but the last five bits of the rotation distance can be
     * ignored, even if the distance is negative: {@code rotateRight(val,
     * distance) == rotateRight(val, distance & 0x1F)}.
     *
     * @return the value obtained by rotating the two's complement binary
     *     representation of the specified {@code int} value right by the
     *     specified number of bits.
     * @since 1.5
     */
    public static int rotateRight(int i, int distance) {
        return (i >>> distance) | (i << -distance);
    }

1
2
3
4
        for (int i = 0; i < 100; i++) {
            System.out.println(buwei(Integer.toBinaryString(i)) + "===" + buwei(Integer.toBinaryString(Integer
                    .rotateRight(i, 4))));
        }

1
2
3
    public static int rotateLeft(int i, int distance) {
        return (i << distance) | (i >>> -distance);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    /**
     * Returns an {@code int} value with at most a single one-bit, in the
     * position of the lowest-order ("rightmost") one-bit in the specified
     * {@code int} value.  Returns zero if the specified value has no
     * one-bits in its two's complement binary representation, that is, if it
     * is equal to zero.
     *
     * @return an {@code int} value with a single one-bit, in the position
     *     of the lowest-order one-bit in the specified value, or zero if
     *     the specified value is itself equal to zero.
     * @since 1.5
     */
    public static int lowestOneBit(int i) {
        // HD, Section 2-1
        return i & -i;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
    /**
     * Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the -XX:AutoBoxCacheMax=<size> option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */

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

1
2
3
4
5
6
        Integer i1=120;
        Integer i2=120;
        Integer i3=130;
        Integer i4=130;
        System.out.println(i1==i2);
        System.out.println(i3==i4);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    /**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    private static String toUnsignedString(int i, int shift) {
         //int类型总共32位
        char[] buf = new char[32];
        int charPos = 32;
        //radix基数，如果是二进制radix为2，如果是16进制radix就为16，一般为2的n次方
        int radix = 1 << shift;
        //这个在讲到HashMap的时候说过，2的n次方减去1则后面全为1，原来为1的位置及之前全为0.
        int mask = radix - 1;
        do {
             //存到数组中
            buf[--charPos] = digits[i & mask];
            //偏移量，这里很好理解，因为Integer是32位，如果shift为3就是八进制，为4就是16进制，这里偏移就是按照多少进制来偏移的。
            i >>>= shift;
        } while (i != 0);

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    private static String toUnsignedString(int i, int shift) {
        //int类型总共32位
        char[] buf = new char[32];
        Arrays.fill(buf, '0');//增加
        int charPos = 32;
        //radix基数，如果是二进制radix为2，如果是16进制radix就为16，一般为2的n次方
        int radix = 1 << shift;
        //这个在讲到HashMap的时候说过，2的n次方减去1则后面全为1，原来为1的位置及之前全为0.
        int mask = radix - 1;
        do {
            //存到数组中
            buf[--charPos] = digits[i & mask];
            //偏移量
            i >>>= shift;
        } while (i != 0);

        //return new String(buf, charPos, (32 - charPos));
        return new String(buf, 0, 32);//修改
    }

1
2
3
        for (int i = -100; i <100 ; i++) {
            System.out.println(toUnsignedString(i,1));
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
11111111111111111111111111110111
11111111111111111111111111111000
11111111111111111111111111111001
11111111111111111111111111111010
11111111111111111111111111111011
11111111111111111111111111111100
11111111111111111111111111111101
11111111111111111111111111111110
11111111111111111111111111111111
00000000000000000000000000000000
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101
00000000000000000000000000000110

1
2
3
4
5
6
7
8
9
    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;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
    /**
     * Places characters representing the integer i into the
     * character array buf. The characters are placed into
     * the buffer backwards starting with the least significant
     * digit at the specified index (exclusive), and working
     * backwards from there.
     *
     * Will fail if i == Integer.MIN_VALUE
     */
     //从注释中可以看出，如果i==Integer.MIN_VALUE，这个方法将失效。
    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为负数，变为正数。
        }

        // Generate two digits per iteration
        while (i >= 65536) {//当大于65536的时候每两位开始操作
            q = i / 100;
        // really: r = i - (q * 100);
	    //r是i对100求余的结果，相当于r=i%100；为什么不这样写，我个人认为应该是效率问题，通过移位操作效率要高一些,
	    //((q << 6) + (q << 5) + (q << 2))相当于q*64+q*32+q*4也就是q*100；
            r = i - ((q << 6) + (q << 5) + (q << 2));
            i = q;
	    //把数字存储到数组中，注意这个数组是从后往前存放的，如果仔细查看DigitTens和DigitOnes，可以发现DigitOnes[r]其实相当于DigitOnes[r%10],
	    //DigitTens[r]其实相当于DigitTens[r/10]
            buf [--charPos] = DigitOnes[r];
            buf [--charPos] = DigitTens[r];
        }

        // Fall thru to fast mode for smaller numbers
        // assert(i <= 65536, i);
        for (;;) {
	    //这里2^19=524288，(i * 52429) >>> (16+3)等于52429/524288=0.1000003814697266,相当于i除以10.因为乘法和移位的效率要高于除法，
	    //至于上面的为什么没有使用乘法和移位，是因为当i大于65536的时候在乘法容易溢出，这里为什么要选择19，待会在下面再看
            q = (i * 52429) >>> (16+3);
	    //求余，相当于r=i-q*10；上面的q约等于i/10;
            r = i - ((q << 3) + (q << 1));  // r = i-(q*10) ...
            buf [--charPos] = digits [r];//存放到数组中。
            i = q;
            if (i == 0) break;
        }
        if (sign != 0) {//如果i为负数，把负号添加到buf的前面，切记buf是从后往前添加的
            buf [--charPos] = sign;
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
	private static void calculate() {
		// 相乘的数不能比max大，否则当i接近65536的时候会出现Integer溢出，
		int max = (int) (Integer.MAX_VALUE * 1.0 / (1 << 16) * 10);// 1<<16相当于65536;
		int j = 0;// 移动j位接近max
		int t = 1;// 临时变量，主要用于计算j的值。
		while (t < max) {
			t = (t << 1);
			j++;
		}
		// 最大移动位j，当1移动j位时相当于调用 highestOneBit(int i)函数。
		for (int m = 1; m <= j; m++) {
			int k = 1 << m;
			int mole = k % 10;
			int q = k / 10;
			if (mole >= 5)// 四舍五入
				q++;
			System.out.println(m + "→→→→" + q * 1.0d / k);
		}
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1
0
1→→→→0.0
2→→→→0.0
3→→→→0.125
4→→→→0.125
5→→→→0.09375
6→→→→0.09375
7→→→→0.1015625
8→→→→0.1015625
9→→→→0.099609375
10→→→→0.099609375
11→→→→0.10009765625
12→→→→0.10009765625
13→→→→0.0999755859375
14→→→→0.0999755859375
15→→→→0.100006103515625
16→→→→0.100006103515625
17→→→→0.09999847412109375
18→→→→0.09999847412109375
19→→→→0.10000038146972656

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
    /**
     * Returns a {@code String} object representing the
     * specified integer. The argument is converted to signed decimal
     * representation and returned as a string, exactly as if the
     * argument and radix 10 were given as arguments to the {@link
     * #toString(int, int)} method.
     *
     * @param   i   an integer to be converted.
     * @return  a string representation of the argument in base 10.
     */
    public static String toString(int i) {
        if (i == Integer.MIN_VALUE)
            return "-2147483648";

        // Android-changed: cache the string literal for small values.
        boolean negative = i < 0;//判断是否是负数
        boolean small = negative ? i > -100 : i < 100;
        if (small) {//如果i大于等于-100并且小于等于100，则从缓存中取
            final String[] smallValues = negative ? SMALL_NEG_VALUES : SMALL_NONNEG_VALUES;

            if (negative) {
                i = -i;
                if (smallValues[i] == null) {//如果缓存为空则创建
                    smallValues[i] =
                        i < 10 ? new String(new char[]{'-', DigitOnes[i]})
                               : new String(new char[]{'-', DigitTens[i], DigitOnes[i]});
                }
            } else {
                if (smallValues[i] == null) {//如果缓存为空则创建
                    smallValues[i] =
                        i < 10 ? new String(new char[]{DigitOnes[i]})
                               : new String(new char[]{DigitTens[i], DigitOnes[i]});
                }
            }
            return smallValues[i];
        }
	//如果不是在缓存的范围之内，则调用getChars方法，看到下面如果为负数时，size会加1，因为在getChars的最后两行要判断符号位的
        int size = negative ? stringSize(-i) + 1 : stringSize(i);
        char[] buf = new char[size];
        getChars(i, size, buf);
        // Android-changed: change string constructor.
        return new String(buf);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
    public static String toString(int i, int radix) {
	//如果radix小于2或者大于36，则返回10进制。Character.MIN_RADIX为2，Character.MAX_RADIX是36
	// public static final int MAX_RADIX = 36;
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;

        /* Use the faster version */
        if (radix == 10) {//如果十进制调用上一个方法
            return toString(i);
        }

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

        if (!negative) {// 如果不为负数，让i变为负数。
            i = -i;
        }

        while (i <= -radix) {
            int q = i / radix;
	    //这里radix * q - i相当于对i求余，如果理解不了可以把radix想象为10进制估计就好一些了
            buf[charPos--] = digits[radix * q - i];
            i = q;
        }
        buf[charPos] = digits[-i];

        if (negative) {// 如果为负数添加负号
            buf[--charPos] = '-';
        }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
    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;// 根据最后一行的判断，result保存的是负数.
        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;//如果是负数，则极限值是Integer.MIN_VALUE
                } else if (firstChar != '+')//如果小于0，并且既不是"-"又不是"+"直接抛异常
                    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) {//数字不能小于0
                    throw NumberFormatException.forInputString(s);
                }
                if (result < multmin) {//如果不判断，下面相乘会出现溢出，超过极限值，为什么要用小于，是因为result和multmin都是负数，
                    throw NumberFormatException.forInputString(s);
                }
		//逐个取出每一个字符与radix相乘，radix表示进制，比如2,8,10,10等，如果还是不好理解，就把radix想象为10进制吧。
                result *= radix;
                if (result < limit + digit) {//这里为什么要这样判断，是因为limit是负数，digit是正数，防止下面的操作导致结果溢出
                    throw NumberFormatException.forInputString(s);
                }
                result -= digit;//注意这里为什么要减，因为result是负数，在最后才进行符号判断
            }
        } else {
            throw NumberFormatException.forInputString(s);
        }
        return negative ? result : -result;//如果知道result是负数，这里就好理解了
    }