java的Integer类源码详解

java的Integer类源码详解

类的定义

public final class Integer extends Number implements Comparable {
    @Native public static final int   MIN_VALUE = 0x80000000;

    @Native public static final int   MAX_VALUE = 0x7fffffff;

    @SuppressWarnings("unchecked")
    public static final Class  TYPE = (Class) Class.getPrimitiveClass("int");

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

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

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

    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 = 65536) {
            q = i / 100;
        // really: r = i - (q * 100);
            r = i - ((q  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();//len是待转换字符串的长度
     int limit = -Integer.MAX_VALUE;//limit = -2147483647
     int multmin;
     int digit;
     //如果待转换字符串长度大于 0 
     if (len > 0) {
         char firstChar = s.charAt(0);//获取待转换字符串的第一个字符
         //这里主要用来判断第一个字符是"+"或者"-"，因为这两个字符的 ASCII码都小于字符'0'
         if (firstChar < '0') {  
             if (firstChar == '-') {//如果第一个字符是'-'
                 negative = true;
                 limit = Integer.MIN_VALUE;
             } else if (firstChar != '+')//如果第一个字符是不是 '+'，直接抛出异常
                 throw NumberFormatException.forInputString(s);
 
             if (len == 1) //待转换字符长度是1，不能是单独的"+"或者"-"，否则抛出异常 
                 throw NumberFormatException.forInputString(s);
             i++;
         }
         multmin = limit / radix;
         //通过不断循环，将字符串除掉第一个字符之后，根据进制不断相乘在相加得到一个正整数
         //比如 parseInt("2abc",16) = 2*16的3次方+10*16的2次方+11*16+12*1 
         //parseInt("123",10) = 1*10的2次方+2*10+3*1 
         while (i < len) {
             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 {//如果待转换字符串长度小于等于0，直接抛出异常
         throw NumberFormatException.forInputString(s);
     }
     //根据第一个字符得到的正负号，在结果前面加上符号
     return negative ? result : -result;
 }

构造方法 Integer(String) 就是将我们输入的字符串数据转换成整型数据。

首先我们必须要知道能转换成整数的字符串必须分为两个部分：第一位必须是"+"或者"-"，剩下的必须是 0-9 和 a-z 字符

parseInt(String s)前面通过 toString(int i) 可以将整型数据转换成字符串类型输出，这里通过 parseInt(String s) 能将字符串转换成整型输出。

自动拆箱和装箱

　　自动拆箱和自动装箱是 JDK1.5 以后才有的功能，也就是java当中众多的语法糖之一，它的执行是在编译期，会根据代码的语法，在生成class文件的时候，决定是否进行拆箱和装箱动作。

　　①、自动装箱

　　我们知道一般创建一个类的对象需要通过 new 关键字，比如：

Object obj = new Object();

　　但是实际上，对于 Integer 类，我们却可以直接这样使用：

Integer a = 128;

　　为什么可以这样，通过反编译工具，我们可以看到，生成的class文件是：

Integer a = Integer.valueOf(128);

　　其实最后返回的也是通过new Integer() 产生的对象，但是这里要注意前面的一段代码，当i的值 -128 > 1); i |= (i >> 2); i |= (i >> 4); i |= (i >> 8); i |= (i >> 16); return i - (i >>> 1); } public static int lowestOneBit(int i) { // HD, Section 2-1 return i & -i; } 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 > 24 == 0) { n += 8; i > 28 == 0) { n += 4; i > 30 == 0) { n += 2; i > 31; return n; } public static int numberOfTrailingZeros(int i) { // HD, Figure 5-14 int y; if (i == 0) return 32; int n = 31; y = 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; } public static int rotateLeft(int i, int distance) { return (i >> -distance); } public static int rotateRight(int i, int distance) { return (i >>> distance) | (i > 1) & 0x55555555; i = (i & 0x33333333) >> 2) & 0x33333333; i = (i & 0x0f0f0f0f) >> 4) & 0x0f0f0f0f; i = (i > 8) & 0xff00) | (i >>> 24); return i; } public static int signum(int i) { // HD, Section 2-7 return (i >> 31) | (-i >>> 31); } public static int reverseBytes(int i) { return ((i >>> 24) ) | ((i >> 8) & 0xFF00) | ((i