JDK源码分析一 Integer 分析

继承Number类，可以转换为int, long, float, double, byte, short等基本类型;

实现了Comparable接口,也重写了两个方法compareTo()和compare();

因为Integer 被final 修饰，故Integer 不能被继承。

Integer有个内部类IntegerCache，静态代码块创建的常量Integer数组，存储-127--128值的Integer对象，
  但是只有采用Integer.valueOf()调用时才会获取已经创建好的Integer数组中的值，但是若是创建的Integer值大于127，
  那么即使使用valueOf()，依然会采用new Integer() 方式进行创建对象;我们在创建对象尽量使用valueOf(),
  【注意】Integer最大值是默认127，我们可以通过修改参数值进行扩大默认值，在启动JVM时通过：
          -Djava.lang.Integer.IntegerCache.high=xxx 就可以改变缓存值的最大值。

 Integer 中提供了两个有参构造函数，详细说说第二个，通过String进行对象创建的构造函数。     以下是源代码：

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

 
 // radix 表示几进制
    public static int parseInt(String s, int radix)
                throws NumberFormatException{
        

        if (s == null) {
            throw new NumberFormatException("null");
        }

        // 判断需要转化的进制是否是2-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; // 传入的s是否是负数
        int i = 0, len = s.length();
        int limit = -Integer.MAX_VALUE;
        int multmin;
        int digit;

        if (len > 0) {
            // 判断第一个字符是否是特殊字符，例如+ ，-    char比较的就是ASCALL码对应的值大小
            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
                // Character.digit() 查看该值各个位有没有超过该进制限定的值，超过则返回-1，没有就返回该数字
                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);
        }
        // 根据negative的值判断返回值是否取反
        return negative ? result : -result;
  }

    // Integer 结果转为byte类型值
    public byte bytevalue() {
        return (byte)value;
    }

    // Integer 结果转为short类型值
    public short shortValue() {
        return (short)value;
    }

    // Integer 结果转为int类型值
    public int intValue() {
        return value;
    }

    // Integer 结果转为long类型值
    public long longValue() {
        return (long)value;
    }

    // Integer 结果转为float类型值
    public float floatValue() {
        return (float)value;
    }

    // Integer 结果转为double类型值
    public double doublevalue() {
        return (double)value;
    }

    // Integer 结果转为String类型值
    public String toString() {
        return toString(value);
    }

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) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
}

 详细看下valueOf(int i) 方法，实现方式是判断i是否在IntegerCache创建好的Integer数组中，若是在直接返回对应的Integer结果即可，若是不在即new  Integer(),通过该方式创建的Integer 对象更方便，利于对象的创建和回收，所以我们在创建Integer对象值应该采用valueOf(int i)方法。