Java装箱拆箱与缓存机制-优快云博客

本文链接：https://blog.youkuaiyun.com/whp404/article/details/84192054

参考以下文章：



public class TEST {
	    public static void main(String[] args) {
	         
	        Integer a = 1;
	        Integer b = 2;
	        Integer c = 3;
	        Integer d = 3;
	        Integer e = 321;
	        Integer f = 321;
	        Long g = 3L;
	        Long h = 2L;
	        //A
	        System.out.println(c==d);
	        System.out.println(e==f);
	        System.out.println(c==(a+b));
	        System.out.println(c.equals(a+b));
	        System.out.println(g==(a+b));
	        System.out.println(g.equals(a+b));
	        System.out.println(g.equals(a+h));
	        
	        
	        //B
	        int i = 40;  
            int i0 = 40;  
            Integer i1 = 40;  
            Integer i2 = 40;  
            Integer i3 = 0;  
            Integer i4 = new Integer(40);  
            Integer i5 = new Integer(40);  
            Integer i6 = new Integer(0);  
            Double d1=1.0;  
            Double d2=1.0;  
              
            System.out.println("i=i0\t" + (i == i0));  
            System.out.println("i1=i2\t" + (i1 == i2));  
            System.out.println("i1=i2+i3\t" + (i1 == i2 + i3));  
            System.out.println("i4=i5\t" + (i4 == i5));  
            System.out.println("i4=i5+i6\t" + (i4 == i5 + i6));      
            System.out.println("d1=d2\t" + (d1==d2));


	    }
}

反正我是没做对，和大家分享一下
从两个博客找的题目，试了一下答案如下：

true
false
true
true
true
false
true
i=i0	true
i1=i2	true
i1=i2+i3	true
i4=i5	false
i4=i5+i6	true
d1=d2	false

在做题之前先补充点知识：

包装类的自动拆箱就是运用xxxvalue()方法，自动装箱是valueof()函数
基本大家都知道,默认情况下，Integer(-127-128)范围内的值会被缓存，但对于其他包装类却没有研究过，下面是其他包装类的对象的缓存机制：

//boolean原生类型自动装箱成Boolean
    public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }

    //byte原生类型自动装箱成Byte
    public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b + offset];
    }

    //byte原生类型自动装箱成Byte
    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);
    }

    //char原生类型自动装箱成Character
    public static Character valueOf(char c) {
        if (c <= 127) { // must cache
            return CharacterCache.cache[(int)c];
        }
        return new Character(c);
    }
    
    //int原生类型自动装箱成Integer
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

    //int原生类型自动装箱成Long
    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);
    }

    //double原生类型自动装箱成Double
    public static Double valueOf(double d) {
        return new Double(d);
    }

    //float原生类型自动装箱成Float
    public static Float valueOf(float f) {
        return new Float(f);
    }

可以看出除了Double和Float类型基本上都有缓存机制，这两个类型没有的原因，
可能是double/float的数值不像Integer那样在指定范围内只有有限个值，所以性能上不划算

A组

主要的考点是：
当 "=="运算符的两个操作数都是包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。另外，对于包装器类型，equals方法并不会进行类型转换。

c==d 和 e==f j基本操作，没啥好说
c==(a+b) a和b 先拆箱 在计算  由于（a+b）已经是基本类型了 所以c 拆箱，那么 3==3 
c.equai(a+b)  会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较，Integer 的equals函数如下，结果为true

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }
    
g==(a+b） g自动拆箱后，左边long 右边int 基本类型比较值，值相等就相等
g.equals(a+b)  Long类型和 Integer肯定不相等
g.equals(a+h)  (a+h) 计算后 自动装箱加 升级 变成Long的包装类了

B组

i == i0 和  i1 == i2 基本操作
i1 == i2 + i3  i2和i3会自动拆箱计算 ，i1自动拆箱
i4 == i5 两个变量 比较 地址 ！不牵涉拆箱和装箱 
i4 == i5 + i6  牵涉拆箱，最后== 两边都是int基本类型
d1==d2  Double没有缓存机制！！

包装类学习（2）

A组

B组