java自动装箱和自动拆箱总结

一，何为自动装箱自动拆箱

　　我们平时创建一个对象的时候可以这样：

　　Class class = new Class();

　　但是Integer可以这样：Integer i = 100;

　　在这个过程中java对基础数据类型进行了装箱操作autoboxing，自动拆箱为反向操作

　　基本数据类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。

二，Integer的自动装箱

　　Integer在自动装箱的时候会调用valueOf方法

    public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
　　
    Integer i = 4;
　　int j = 4;
　　i = i+4;//先对i进行拆箱操作，执行完+在进行装箱操作

    Integer a = 128;
　　 int b = 128;
    System.out.println(a==b);//true
　　int和Integer比永远为true，因为比较前Integer会先拆箱为基础数据类型，值比较了

　　当-128-127之间的数装箱时会从缓冲区返回，在此之外的会重新new一个

三，Double和Float的自动装箱

　　由于double和float没法缓存，所以他们在自动装箱的时候都会new一个新的　

    #double autoboxing
    public static Double valueOf(double d) {
        return new Double(d);
    }

    #float autoboxing
    public static Float valueOf(float f) {
        return new Float(f);
    }

四，char的自动装箱　

　　#当要装箱的char的ascii值在127以内会从缓存里直接取
　　#没在此列的会new
　　public static Character valueOf(char c) {
        if (c <= 127) { // must cache
            return CharacterCache.cache[(int)c];
        }
        return new Character(c);
    }

五，byte的自动装箱

   #都从缓存中返回
　　public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b + offset];
    }

六，boolean

   #缓存返回
　　public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FALSE = new Boolean(false);
    public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }

七，long

    #-128-127从缓存中返回
    public static Long valueOf(long l) {
        final int offset = 128;
        if (l >= -128 && l <= 127) { // will cache
            return LongCache.cache[(int)l + offset];
        }
        return new Long(l);
    }

八，short

    #-128-127从缓存中返回
　　public static Short valueOf(short s) {
        final int offset = 128;
        int sAsInt = s;
        if (sAsInt >= -128 && sAsInt <= 127) { // must cache
            return ShortCache.cache[sAsInt + offset];
        }
        return new Short(s);
    }

装箱操作实用不当可能会有不必要的性能开销

举个例子：

        Integer ig = 0;
        for(int j=0;j<4000;j++){
            ig+=j;//会产生好多没用的中间对象
        }