自动装箱与拆箱：Integer & int

一、包装类型

Java：面向对象，不过Java中的基本数据类型却是不面向对象的，不过在设计类时为每个基本数据类型设计了一个对应的类进行代表，所以八个和基本数据类型对应的类统称为包装类(Wrapper Class)。包装类均位于java.lang包，包装类和基本数据类型的对应关系如下表所示：

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

二、关于对象

Java是一种面向对象语言，很多地方都需要使用对象而不是基本数据类型。比如，在集合类中，我们是无法将int 、double等类型放进去的。因为集合的容器要求元素是Object类型。为了让基本类型也具有对象的特征，就出现了包装类型，它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

三、拆箱与装箱

在Java SE5之前，要进行装箱，可以通过以下代码：

Integer i = new Integer(10);

四、自动拆箱与装箱

从Java SE5中，Java提供了自动拆箱与自动装箱功能。自动装箱: 就是将基本数据类型自动转换成对应的包装类。自动拆箱：就是将包装类自动转换成对应的基本数据类型。 

Integer i =10;  //自动装箱
int b= i;     //自动拆箱

Integer i=10 可以替代 Integer i = new Integer(10); 这就是因为Java帮我们提供了自动装箱的功能，不需要开发者手动去new一个Integer对象。

有如下代码：

int a = 3;
int b = 3;
		
Integer c = 300;
Integer d = 300;
		
System.out.println(a==b);//true
System.out.println(c==d);//false
System.out.println(c.equals(d));//true

反编译后：

int a = integer.intValue(3); 
int b = integer.intValue(3); 

Integer c = Integer.valueOf(300); 
Integer d = Integer.valueOf(300); 

由上可知：自动装箱都是通过包装类的valueOf()方法来实现的.自动拆箱都是通过包装类对象的xxxValue()来实现的。

则源码中valueOf（）：

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

源码中xxxValue（）:

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

五、IntegerCache

Integer下c 和 d 都是300，为什么结果是false，在第四段中有段Integer的valueOf（）源码中有一个IntegerCache，先看下它的源码：

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() {}
}

在Java 5中，在Integer的操作上引入了一个新功能来节省内存和提高性能。整型对象通过使用相同的对象引用实现了缓存和重用。适用于整数值区间-128 至 +127。只适用于自动装箱。使用构造函数创建对象不适用。当需要进行自动装箱时，如果数字在-128至127之间时，会直接使用缓存中的对象，而不是重新创建一个对象。

其中的Java Doc详细的说明了缓存支持-128到127之间的自动装箱过程。最大值127可以通过-XX:AutoBoxCacheMax=size修改。实际上这个功能在Java 5中引入的时候,范围是固定的-128 至 +127。后来可以通过java.lang.Integer.IntegerCache.high设置最大值。即源码中的这一句话：

在Java中，==比较的是对象应用，而equals比较的是值。所以，在这个例子中，不同的对象有不同的引用，所以在进行比较的时候都将返回false。