【Java源码分析】Integer源码分析

ゝ一纸荒年。 2022-05-27 08:54 290阅读 0赞

今天带来的是Integer源码的分析。代码已经注释的非常清晰了。

1.parseInt方法

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.
             */
            //String转换为Integter，不能是null
            if (s == null) {
                throw new NumberFormatException("null");
            }
            //最小二进制，最大36进制
            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;	//如果是正数negative = false，如果是负数negative = true
            int i = 0, len = s.length();	//i是遍历String的下标，len是长度
            int limit = -Integer.MAX_VALUE;	//限制，不能超过Integer的最大值。负的MAX_VALUE(以下都是再负数范围内进行判断的，为了统一处理，因为正数的最大值转化为负数不会溢出，而负数的最小值转换为正数会溢出，我这里所说的溢出是指的Integer范围内)
            int multmin;	//一个限制，后面讲
            int digit;		//每个字符转换为数字后的值
    
            //如果是非空字符串
            if (len > 0) {
                char firstChar = s.charAt(0);	
                if (firstChar < '0') { // Possible leading "+" or "-"//ASCII码表小于‘0’的都是字符
                    if (firstChar == '-') {		//如果是负号
                        negative = true;	//标志改为负号
                        limit = Integer.MIN_VALUE;		//界限是Integer最小值
                    } else if (firstChar != '+')	//如果不是加号，说明第一个符号是个非法字符，抛出异常
                        throw NumberFormatException.forInputString(s);
    
                    if (len == 1) // 不能只有一个 "+" 或者 "-"
                        throw NumberFormatException.forInputString(s);
                    i++;	//i指向第一个数字的位置
                }
                //下面就是转换成数字的逻辑了。
                /*有很多小伙伴到这里可能不是很懂。首先limit表示溢出边界范围（这个程序中，无论正负，都统一成了负数），radix表示进制。
                	举个例子：假设十进制，我们到77就代表溢出了，那么multmin = -77 / 10 = -7，为什么要算这个数，是为了后面的操作。*/
                //这里可以用移位操作吧？
                multmin = limit / radix;
                while (i < len) {	//i没越界，执行字符转换成数字
                    // Accumulating negatively avoids surprises near MAX_VALUE
                    digit = Character.digit(s.charAt(i++),radix);	//字符转换成数字
                    if (digit < 0) {	//转换出来如果每一位是负数，抛出异常
                        throw NumberFormatException.forInputString(s);
                    }
                    //关键来了：当前结果是否小于multmin，如果小于，抛出溢出异常。注意multmin一直是负数，如果result比multmin还要小，说明执行 result *= radix 的时候肯定是溢出了（以咱们的例子继续，multmin为-7，result < multmin，假设result为-9，那么执行result *= radix，result变成了-90，就发生了溢出 ），如果不提前抛出异常，那么我们的result中存的是溢出后的结果（结果不准确了）
                    if (result < multmin) {
                        throw NumberFormatException.forInputString(s);
                    }
                    result *= radix;	
                    //这里又是一个溢出判断,注意：digit是非负数，result，limit是负数。
                    //换成result - digit < limit你可能更好理解，继续我们的例子，假设result = -70，digit = 9， -70 - 9 =- 79， 是小于-77的，这就发生了溢出。
                    //但是为什么不换成result - digit < limit呢，因为在这里，做减法可能发生溢出。当我们算出-79的时候，result就已经发生了溢出，所以就将表达式变换了一下result < limit + digit，防止了溢出
                    if (result < limit + digit) {
                        throw NumberFormatException.forInputString(s);
                    }
                    result -= digit;	//在没有溢出的情况下，算出result
                }
            //如果字符串是空串，直接抛出异常
            } else {
                throw NumberFormatException.forInputString(s);
            }
            return negative ? result : -result;	//判断标志，如果是负数，返回result，如果是正数，返回-result
        }

2.IntegerCache内部类

/**
         * Integer默认缓存-128到127之间的数，缓存在第一次使用时初始化。缓存的大小是可控制的，在server模式下用-XX:AutoBoxCacheMax=<size>
         */
    
        private static class IntegerCache {
            static final int low = -128;	//注意，这个值自始至终没有变过，所以下限一直是-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");	//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);	//注意，这里刚开始看可能很突兀，为什么是Integer.MAX_VALUE - (-low) -1呢？因为创建的是一个在low到high范围的Integer数组，如果大于了这个值，那么在为数组分配空间的时候就溢出了
                    } catch( NumberFormatException nfe) {
                        // If the property cannot be parsed into an int, ignore it.
                    }
                }
                high = h;
    
                cache = new Integer[(high - low) + 1];	//缓存的最大空间是Integer.MAX_VALUE，这就是为什么h的最大值是Integer.MAX_VALUE - (-low) -1的原因了
                int j = low; 
                for(int k = 0; k < cache.length; k++)	//缓存的最大范围是-128到MAX_VALUE - (-low) -1
                    cache[k] = new Integer(j++);
    
                // range [-128, 127] must be interned (JLS7 5.1.7)
                assert IntegerCache.high >= 127;
            }
    
            private IntegerCache() {}
        }

3.toString方法

/**
         * 返回第一个参数用第二参数表示的字符串形式，第二个参数是进制数，默认是10进制
         *
         * 如果第一个参数是负的，那么返回结果中第一个字符是'-'，如果第一个参数是正的，那么返回的结果中没有符号
         * 结果中剩余的字符表示第一个参数的大小
         *
         * @see     java.lang.Character#MAX_RADIX
         * @see     java.lang.Character#MIN_RADIX
         */
        public static String toString(int i, int radix) {
            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;
            }
    
            while (i <= -radix) {
                buf[charPos--] = digits[-(i % radix)];   //取余法进行进制转换，从buf的最后向前面添加
                i = i / radix;							//取整数部分
            }							
            buf[charPos] = digits[-i];	//最后剩下一位单独处理
    
            if (negative) {			//如果是负数就添加'-'号
                buf[--charPos] = '-';
            }
    
            return new String(buf, charPos, (33 - charPos));
        }