Integer类详解

问题一：
一直很好奇一件事，类似于Integer i = 15; String s = “aa”;之类的代码是怎么实现的？
Integer和String是一个类，i，s是对应的对象，对象的创建需要new出来(不讨论反射）,但是上面的对象怎么创建的？
于是去找Integer的构造函数，在第849行找到了。。。（构造函数不都放在前面么），如下：

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

只此两个构造函数，一个传入int形参，一个传入String形参。还是没解决问题！按理说应该且必须类似于new Integer(10);这样创建对象啊！！
于是在Integer类中搜索"new Integer("字样。一共搜索到了两处，一处在内部类IntegerCache中出现，一处在public static Integer valueOf(int i){}方法体中出现，并且该方法体中出现了IntegerCache内部类，更神奇的是内部类IntegerCache只在该方法体中出现，于是得出结论：该内部类就是为该方法而创建。于是分析一下这个ValueOf(int i)方法：

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

看到最后一个return语句，那肯定可以通过valueOf这个静态方法创建对象，实验一下果然成功了。
所以Integer只有两种方式创建对象：直接创建和间接创建。①new Integer(10) ②Integer.valueOf(10)。开头那种神奇的方法是用哪一种？？
于是通过反编译工具将代码生成java文件后，神奇发现Integer i = 10变成了Integer i = Integer.valueOf(10);
所以问题解决了，编译器将代码处理成了valueOf方法去创建对象！！


问题二：
好像没什么问题了，想了想为什么编译器不直接处理成new integer(10);上文可说了有两种创建对象的方法，那个内部类是干什么用的？还专门为valueOf(int i)方法创建一个内部类？

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

再看这个方法，只有i值在[IntegerCache.low, IntegerCache.high]范围内才会调用内部类创建对象，并且返回的是类成员变量cache数组的一个值，那这个数组里面肯定就是存的对象咯。再看看这个内部类。

private static class IntegerCache {
        static final int low = -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");
            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];
            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() {}
    }

读完意思就是：类静态变量cache存储-128到127之间的Integer对象，静态代码块已经初始化好了。
也就意味着valueOf(int i)中i在-128到127之间时，直接去cache中根据下标取对象就行，对象已经创建好了。

问题三：
那？这是何必呢？是不是还意味着Integer a = 10; Integer b = 10;后a和b是同一个对象呢？不知道。用==号实验一下，果然，结果是ture！
那么用意何在？
个人猜测是为了避免反复创建-128到127之间的相同对象吧。那。那也创建了256个对象？能节约内存？

常用方法：

① int转Integer

public int intValue() {
        return value;
    }

② String转Integer

//若字符串中有非数字则抛异常
public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
    }

③ Integer转其他七个基本数据类型

public byte byteValue() {
        return (byte)value;
    }

public short shortValue() {
    return (short)value;
}

public int intValue() {
    return value;
}

public long longValue() {
    return (long)value;
}

public float floatValue() {
    return (float)value;
}

public double doubleValue() {
    return (double)value;
}

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