java Integer类

 Integer是int类型的包装类，底层就是一个int 类型的成员属性

 private final int value;

 与之类似的，所有基本数据类型都有他对应的包装类类型。

1.继承体系

public final class Integer extends Number implements Comparable<Integer> {

        实现了Comparable接口，重写了CompareTo方法

public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }

2.父类Number

Number类是所有基本数据类型（除去boolean和char）的包装类的父类，，他是一个抽象类，里面提供的抽象方法为：

 继承Number的包装类都要提供上面这些方法，实现将当前包装类数据类型转换成其他基本数据类型，当然，大数据类型转换成小数据类型会损失精度。因为他们的底层都是实现的强制转换

    
    public int intValue() { //除了自己的包装类对应的基本数据类型之外，转换为其他的基本数据类型都是强制转换
        return value; 
    }
    public short shortValue() {
        return (short)value;
    }
    public long longValue() {
        return (long)value;
    }

3.构造方法

        Integer中的构造方法有两个，但均已过时，不建议使用，代替他们的是valueOf方法

  public Integer(int value) {
        this.value = value;
    }

  public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10); //将字符串转成int型后赋值给value;
    }

4.valueOf

        valueOf方法有三个重载，用于替代构造方法使用，参数可以是数字型的字符串或者int数据

如果是字符串，则会调用parseInt方法将指定进制的字符串（不指定则为10进制）转换成对应的int数据，然后调用一个int型参数的valueOf方法返回对应的Integer对象，这里涉及到Interger的缓存问题，在下面讲解。

  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) { //如果i在-128到127范围内，返回cache缓存里面对应的Integer数据
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i); //否则直接返回一个新对象
    }

5.Integer的缓存

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];//cache这个数组里面存放-128-127的integer数据

        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) {
                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);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];//声明一个长度为256的Integer数组
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++); //循环给数组赋值

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

测试代码

 Integer i1=new Integer(100);
 Integer i2=new Integer(100); //构造方法每次返回一个新的Integer对象
 System.out.println(i1==i2);//false
 Integer i3= Integer.valueOf(100);//valueOf方法如果在-128到127之内，会从缓存取出Interger对象返回
 Integer i4= Integer.valueOf(100);
 System.out.println(i3==i4);//true
 System.out.println(i1==i3);//false
 Integer i5= Integer.valueOf(128);//valueOf方法如果不在-128-127之内，返回新的对象
 Integer i6= Integer.valueOf(128);
 System.out.println(i5==i6);//false

运行结果：

6.自动装箱和自动拆箱

 Integer i=10; //自动装箱 底层调用了valueOf方法
 int n=i; //自动拆箱 底层调用了intValue方法

7.数字型字符串和int和之间的转换

        //int->Integer
        Integer i1=Integer.valueOf(10);
        //String->Integer
        Integer i2=Integer.valueOf("10");//不指定进制默认为10进制
        Integer i3=Integer.valueOf("10",2);//指定进制
        System.out.println(i1+","+i2+","+i3);

        //Integer->int
        int i=i1.intValue();

        //int->String
        System.out.println(Integer.toBinaryString(10));//转成2进制字符串
        System.out.println(Integer.toHexString(10));//转成16进制字符串
        System.out.println(Integer.toOctalString(10)); //转成8进制字符串

        System.out.println(i1.toString());//这是重写的Object中的toString方法，底层调用                    
        Integer.toString(this.value),转为10进制字符串;
        System.out.println(Integer.toString(10));//不指定进制默认转成10进制字符串
        System.out.println(Integer.toString(10,16));//转成指定进制字符串

        //String->int
        System.out.println(Integer.parseInt("1010",2));//将指定进制的字符串转换为int
        System.out.println(Integer.parseInt("1010")); //不指定进制，默认解析为10进制字符串