java.lang.*中Integer 源代码详解

桃扇骨 2022-12-03 08:55 139阅读 0赞

### java.lang.\*中Integer 源代码详解 ###

*   *  核心方法
     *  String toString(int i, int radix)
     *  String toUnsignedString(int i, int radix)
     *  String toHexString(int i)
     *  String toOctalString(int i)
     *  String toString(int i)
     *  String toUnsignedString(int i)
     *  int parseInt(String s, int radix)
     *  int parseUnsignedInt(String s, int radix)
     *  Integer valueOf(String s, int radix)
     *  public Integer(int value)
     *  int hashCode(int value)
     *  boolean equals(Object obj)
     *  Integer getInteger(String nm)
     *  Integer decode(String nm)
     *  int compareTo(Integer anotherInteger)
     *  int compareUnsigned(int x, int y)
     *  int divideUnsigned(int dividend, int divisor)
     *  int remainderUnsigned(int dividend, int divisor)
     *  int highestOneBit(int i)
     *  int lowestOneBit(int i)
     *  int numberOfLeadingZeros(int i)
     *  int numberOfTrailingZeros(int i)
     *  int bitCount(int i)
     *  int rotateLeft(int i, int distance)
     *  int rotateRight(int i, int distance)
     *  int reverse(int i)
     *  int signum(int i)
     *  int reverseBytes(int i)

> 学习Java的同学注意了！！！  
> 学习过程中遇到什么问题或者想获取学习资源的话，欢迎加入Java学习交流群，群号码：543120397 我们一起学Java！

## 核心方法 ##

String toString(int i, int radix) 获取i的radix进制形式,最多36进制[OK]
    String toUnsignedString(int i, int radix) 获取i的radix进制字符串形式,最多36进制(不带符号位)[OK]
    String toHexString(int i) 获取16进制字符串结果[OK]
    String toOctalString(int i) 获取8进制字符串结果[OK]
    String toBinaryString(int i) 获取2进制字符串结果[OK] 
    String toString(int i) 获取Integer对象的字符串形式[OK]
    String toUnsignedString(int i) 获取Integer对象的无符号字符串形式[OK]
    int parseInt(String s, int radix) 将字符串按radix进制转为int数值[OK]
    int parseUnsignedInt(String s, int radix) 按照radix转换无符号位字符串数值为int类型[OK]
    Integer valueOf(String s, int radix) 将字符串s按照radix进制,转化为int类型数值[OK]
    public Integer(int value) 构造方法[OK]
    int hashCode(int value) 获取Integer对象的HashCode值[OK]
    boolean equals(Object obj) 比较两个对象的值是否相等[OK]
    Integer getInteger(String nm) 从System.properties中获取属性值,并转为int值[OK]
    Integer decode(String nm) 方法解码字符串转换为整数[OK]
    int compareTo(Integer anotherInteger) 比较两个Integer对象的值,如果相等返回0[OK]
    int compareUnsigned(int x, int y) 比较两个 int值，以数值方式将值视为无符号[OK]
    int divideUnsigned(int dividend, int divisor) 返回将第一个参数除以秒的无符号商，其中每个参数和结果被解释为无符号值[OK]
    int remainderUnsigned(int dividend, int divisor) 返回无符号余数，将第一个参数除以秒，其中每个参数和结果被解释为无符号值[OK]
    int highestOneBit(int i) 返回一个 int值与至多一个单个1位，在最高阶（“最左侧”）的位置在指定的一个位 int值[OK]
    int lowestOneBit(int i) 在指定的 int值中，以最低位（最右边）为1位返回一个最多为单个1位的 int值[OK]
    int numberOfLeadingZeros(int i) 返回的最高阶的（“最左边的”）中所指定的二进制补码表示的一个位前述零个比特的数量 int值[OK]
    int numberOfTrailingZeros(int i) 返回零位以下最低阶（“最右边的”）的数量在指定的二进制补码表示的一个位 int值[OK]
    int bitCount(int i) 返回指定的int值的二进制补码二进制表示中的 int数[OK]
    int rotateLeft(int i, int distance) 返回通过旋转指定的二的补码的二进制表示而得到的值 int由位指定数目的左值[OK]
    int rotateRight(int i, int distance) 返回通过旋转指定的二的补码的二进制表示而得到的值 int右移位的指定数值[OK]
    int reverse(int i) 指定的二进制补码表示反转位的顺序而获得的值 int值[OK]
    int signum(int i) 返回指定的int值的signum函数[OK]
    int reverseBytes(int i) 返回反转指定的二进制补码表示的字节顺序而获得的值 int值[OK]

## String toString(int i, int radix) ##

/** * 获取i的radix进制字符串形式,最多36进制 * 样例： * Integer.toString(-10,2) * 输出结果: * -1010 */
    public static String toString(int i, int radix) { 
    	//如果radix不在[2,36]范围内时,radix默认为10进制
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;
    
        /* Use the faster version */
        if (radix == 10) { 
            return toString(i);
        }
    	//int最大值的2进制,再加上符号位,总共33位
        char buf[] = new char[33];
        boolean negative = (i < 0);//判断是否为负数
        int charPos = 32;
    
        if (!negative) { //如果i为正数,将其转为负数进行进制转换
            i = -i;
        }
    
        while (i <= -radix) { //直到i<=-radix
        	//将i对radix取余,去对应进制表的数组中寻找对应符号
        	//buf[charPos--]从后往前往buf数组中插入进制符号
            buf[charPos--] = digits[-(i % radix)];
            //将i的值除以radix取整,作为一次循环处理逻辑
            i = i / radix;
        }
        //将最后剩下的i,取到对应的符号,塞到charPos位置
        buf[charPos] = digits[-i];
    
        if (negative) { //最后根据negative符号,拼接符号位
            buf[--charPos] = '-';
        }
    	//最后输出结果
        return new String(buf, charPos, (33 - charPos));
    }

## String toUnsignedString(int i, int radix) ##

/** * 获取i的radix进制字符串形式,最多36进制 * 样例： * Integer.toUnsignedString(-0x800000,2) * 输出结果: * 11111111100000000000000000000000 */
    public static String toUnsignedString(int i, int radix) { 
        return Long.toUnsignedString(toUnsignedLong(i), radix);
    }
    
    public static long toUnsignedLong(int x) { 
        return ((long) x) & 0xffffffffL;
    }
    
    public static String toUnsignedString(long i, int radix) { 
        if (i >= 0)
            return toString(i, radix);
        else { 
            switch (radix) { 
            case 2:
                return toBinaryString(i);
    
            case 4:
                return toUnsignedString0(i, 2);
    
            case 8:
                return toOctalString(i);
    
            case 10:
                /* * We can get the effect of an unsigned division by 10 * on a long value by first shifting right, yielding a * positive value, and then dividing by 5. This * allows the last digit and preceding digits to be * isolated more quickly than by an initial conversion * to BigInteger. */
                long quot = (i >>> 1) / 5;
                long rem = i - quot * 10;
                return toString(quot) + rem;
    
            case 16:
                return toHexString(i);
    
            case 32:
                return toUnsignedString0(i, 5);
    
            default:
                return toUnsignedBigInteger(i).toString(radix);
            }
        }
    }
    
    public static String toString(long i, int radix) { 
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;
        if (radix == 10)
            return toString(i);
        char[] buf = new char[65];
        int charPos = 64;
        boolean negative = (i < 0);
    
        if (!negative) { 
            i = -i;
        }
    
        while (i <= -radix) { 
            buf[charPos--] = Integer.digits[(int)(-(i % radix))];
            i = i / radix;
        }
        buf[charPos] = Integer.digits[(int)(-i)];
    
        if (negative) { 
            buf[--charPos] = '-';
        }
    
        return new String(buf, charPos, (65 - charPos));
    }

## String toHexString(int i) ##

public static String toHexString(int i) { 
        return toUnsignedString0(i, 4);
    }

## String toOctalString(int i) ##

public static String toOctalString(int i) { 
        return toUnsignedString0(i, 3);
    }

## String toString(int i) ##

/** * 获取Integer对象的字符串形式 */
    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);
    }

## String toUnsignedString(int i) ##

/** * 获取Integer对象的无符号字符串形式 */
    public static String toUnsignedString(int i, int radix) { 
        return Long.toUnsignedString(toUnsignedLong(i), radix);
    }
    
    public static String toUnsignedString(long i, int radix) { 
        if (i >= 0)
            return toString(i, radix);
        else { 
            switch (radix) { 
            case 2:
                return toBinaryString(i);
    
            case 4:
                return toUnsignedString0(i, 2);
    
            case 8:
                return toOctalString(i);
    
            case 10:
                /* * We can get the effect of an unsigned division by 10 * on a long value by first shifting right, yielding a * positive value, and then dividing by 5. This * allows the last digit and preceding digits to be * isolated more quickly than by an initial conversion * to BigInteger. */
                long quot = (i >>> 1) / 5;
                long rem = i - quot * 10;
                return toString(quot) + rem;
    
            case 16:
                return toHexString(i);
    
            case 32:
                return toUnsignedString0(i, 5);
    
            default:
                return toUnsignedBigInteger(i).toString(radix);
            }
        }

## int parseInt(String s, int radix) ##

/** * 将字符串按radix进制转为int数值 * 默认是10进制 */
    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;
        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;
                } 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;
                if (result < limit + digit) { 
                    throw NumberFormatException.forInputString(s);
                }
                result -= digit;
            }
        } else { 
            throw NumberFormatException.forInputString(s);
        }
        return negative ? result : -result;
    }

## int parseUnsignedInt(String s, int radix) ##

/** * 按照radix转换无符号位字符串数值为int类型 */
    public static int parseUnsignedInt(String s) throws NumberFormatException { 
        return parseUnsignedInt(s, 10);
    }
    
    public static int parseUnsignedInt(String s, int radix)
                    throws NumberFormatException { 
        if (s == null)  { //判断s是否为null 
            throw new NumberFormatException("null");
        }
    
        int len = s.length();
        if (len > 0) { 
        	//获取字符串首号位置的字符
            char firstChar = s.charAt(0);
            //如果是以-开头,则抛出异常
            if (firstChar == '-') { 
                throw new
                    NumberFormatException(String.format("Illegal leading minus sign " +
                                                       "on unsigned string %s.", s));
            } else { 
            	//按照36进制,int类型的值最多存储5位
                if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
                    (radix == 10 && len <= 9) ) {  // Integer.MAX_VALUE in base 10 is 10 digits
                    return parseInt(s, radix);
                } else { 
                    long ell = Long.parseLong(s, radix);
                    if ((ell & 0xffff_ffff_0000_0000L) == 0) { 
                        return (int) ell;
                    } else { 
                        throw new
                            NumberFormatException(String.format("String value %s exceeds " +
                                                                "range of unsigned int.", s));
                    }
                }
            }
        } else { 
            throw NumberFormatException.forInputString(s);
        }
    }

## Integer valueOf(String s, int radix) ##

/** * 将字符串s按照radix进制,转化为int类型数值 * 底层调用的是parseInt方法 */
    public static Integer valueOf(String s, int radix) throws NumberFormatException { 
        return Integer.valueOf(parseInt(s,radix));
    }

## public Integer(int value) ##

public Integer(int value) { 
        this.value = value;
    }
    
    public Integer(String s) throws NumberFormatException { 
        this.value = parseInt(s, 10);
    }

## int hashCode(int value) ##

/** * 获取Integer对象的hashCode值 */
    public int hashCode() { 
        return Integer.hashCode(value);
    }
    
    public static int hashCode(int value) { 
        return value;
    }

## boolean equals(Object obj) ##

public boolean equals(Object obj) { 
    	//首先判断obj是否为Integer类型
        if (obj instanceof Integer) { 
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

## Integer getInteger(String nm) ##

/** * 从System.properties中获取属性值,并转为int值 */
    public static Integer getInteger(String nm) { 
        return getInteger(nm, null);
    }
    
    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;
    }

## Integer decode(String nm) ##

/** * 方法解码字符串转换为整数 * 它接受十进制，十六进制和八进制数 * 样例： * System.out.println(Integer.decode("#20")); System.out.println(Integer.decode("0x20")); System.out.println(Integer.decode("0X20")); System.out.println(Integer.decode("020")); 输出结果： 32 32 32 16 */
    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)) { 
            index += 2;
            radix = 16;
        }
        else if (nm.startsWith("#", index)) { 
            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;
    }

## int compareTo(Integer anotherInteger) ##

/** * 比较两个Integer对象的值 * 如果相等返回0 * 如果不相等返回-1或者1 */
    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 compareUnsigned(int x, int y) ##

/** * 比较两个int值，以数值方式将值视为无符号 */
    public static int compareUnsigned(int x, int y) { 
        return compare(x + MIN_VALUE, y + MIN_VALUE);
    }

## int divideUnsigned(int dividend, int divisor) ##

/** * 返回将第一个参数除以秒的无符号商，其中每个参数和结果被解释为无符号值 */
    public static int divideUnsigned(int dividend, int divisor) { 
        // In lieu of tricky code, for now just use long arithmetic.
        return (int)(toUnsignedLong(dividend) / toUnsignedLong(divisor));
    }

## int remainderUnsigned(int dividend, int divisor) ##

/** * 返回无符号余数，将第一个参数除以秒，其中每个参数和结果被解释为无符号值 */
    public static int remainderUnsigned(int dividend, int divisor) { 
        // In lieu of tricky code, for now just use long arithmetic.
        return (int)(toUnsignedLong(dividend) % toUnsignedLong(divisor));
    }

## int highestOneBit(int i) ##

/** * 返回一个 int值与至多一个单个1位，在最高阶（“最左侧”）的位置在指定的一个位 int值 */
    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);
    }

## int lowestOneBit(int i) ##

/** * 在指定的 int值中，以最低位（最右边）为1位返回一个最多为单个1位的 int值 */
    public static int lowestOneBit(int i) { 
        // HD, Section 2-1
        return i & -i;
    }

## int numberOfLeadingZeros(int i) ##

/** * 返回的最高阶的（“最左边的”）中所指定的二进制补码表示的一个位前述零个比特的数量 int值 */
    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;
    }

## int numberOfTrailingZeros(int i) ##

/** * 返回零位以下最低阶（“最右边的”）的数量在指定的二进制补码表示的一个位 int值 */
    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);
    }

## int bitCount(int i) ##

/** * 返回指定的int值的二进制补码二进制表示中的 int数 */
    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;
    }

## int rotateLeft(int i, int distance) ##

/** * 返回通过旋转指定的二的补码的二进制表示而得到的值 int由位指定数目的左值 */
    public static int rotateLeft(int i, int distance) { 
        return (i << distance) | (i >>> -distance);
    }

## int rotateRight(int i, int distance) ##

/** * 返回通过旋转指定的二的补码的二进制表示而得到的值 int右移位的指定数值 */
    public static int rotateRight(int i, int distance) { 
        return (i >>> distance) | (i << -distance);
    }

## int reverse(int i) ##

/** * 指定的二进制补码表示反转位的顺序而获得的值 int值 */
    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;
    }

## int signum(int i) ##

/** * 返回指定的int值的signum函数 * 如果指定的值为负，返回值为-1;如果指定的值为零，返回值为0;如果指定的值为正，返回值为1 */
    public static int signum(int i) { 
        // HD, Section 2-7
        return (i >> 31) | (-i >>> 31);
    }

## int reverseBytes(int i) ##

/* * 返回反转指定的二进制补码表示的字节顺序而获得的值 int值 */
    public static int reverseBytes(int i) { 
        return ((i >>> 24)           ) |
               ((i >>   8) &   0xFF00) |
               ((i <<   8) & 0xFF0000) |
               ((i << 24));
    }