精华内容
参与话题
问答
  • 自动装箱和自动拆箱

    2019-07-17 13:42:56
    自动装箱和自动拆箱的问题 昨天老师讲了包装类,学习的目标是要理解自动装箱和自动拆箱的原理,老师留了个课后作业,题目如下: public class demo { public static void main(String[] args) { Integer a1 = 127; ...

    自动装箱和自动拆箱的问题

    昨天老师讲了包装类,学习的目标是要理解自动装箱和自动拆箱的原理,老师留了个课后作业,题目如下:

    public class demo {
        public static void main(String[] args) {
            Integer a1 = 127;
            Integer a2 = 127;
            Integer b1 = 128;
            Integer b2 = 128;
            System.out.println(a1 == a2);      //true
            System.out.println(b1 == b2);      //false
        }
    }
    

    答案第一个输出的为什么是·true呢?或许你会有这样的疑问,Integer不是包装类嘛,不是应该存在堆内存中嘛,为什么a1 == a2 是true这样,其实这里就包含了自动装箱和自动拆箱的原理。

    1.什么是自动装箱?
    自动装箱:将基本数据类型自动转成包装类
    如 :

       		Integer a = 127;
       	 //实际上是做了如下操作:
       		Integer a = Integer.valueOf(127);
    

    2.什么是自动拆箱?
    自动拆箱:将包装类自动转成基本数据类型
    如:

            Integer a= 127;
            int b = a;         //自动拆箱
    	//实际上是:
            Integer a = Integer.valueOf(3);
            int b = a.intValue();
    

    我们可以用反编译工具看看是不是这样的,把编译运行后的demo.class文件拖到反编译工具,代码如图:
    在这里插入图片描述
    接下来我们可以查看Integer的valueof的底层源码,注释的意思是:“该方法将始终缓存-128到127范围内的值(包括),并且可能缓存此范围之外的其他值。”

         * This method will always cache values in the range -128 to 127,
         * inclusive, and may cache other values outside of this range.
         *
         * @param  i an {@code int} value.
         * @return an {@code Integer} instance representing {@code i}.
         * @since  1.5
         */
        @HotSpotIntrinsicCandidate
        public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
    

    1、a1和a2会进行自动装箱,执行了valueOf函数,它们的值在-128-127]这个范围内,然后会返回 IntegerCache.cache[i + (-IntegerCache.low)],也就是写入缓存,a1和a2引用到了同一个Integer对象,所以它们肯定是相等的。

    2、b3和b4也进行自动装箱,执行了valueOf函数,它们的值大于128,所以会执行new Integer(128),也就是说它们会分别创建两个不同的对象,所以它们肯定不等。

    由此我们可以得知结果了,步骤其实不难理解,就只是进行了隐式装箱,然后查看Integer的valueOf方法的源码就清楚了。

    展开全文
  • 自动装箱 auto-boxing 基本类型就自动地封装到与它相同类型的包装中,如: Integer i= 100; 本质上是,编译器编译时为我们添加了: Integer i = new Integer(100);     自动拆箱 unboxing: 包装类对象...

     

    自动装箱 auto-boxing

    基本类型就自动地封装到与它相同类型的包装中,如:

    Integer i= 100;

    本质上是,编译器编译时为我们添加了:

    Integer i = new Integer(100);

     

     

    自动拆箱 unboxing:

    包装类对象自动转换成基本类型数据,如:

    int a = new Integer(100);

    本质上,编译器编译时为我们添加了:

    int a = new Integer(100).intValue();

     

    缓存问题

     

    intValue就是把Integer类型转化为int类型

    /**
     * 测试自动装箱和自动拆箱
     * (加了代码而已)
     * @author Administrator
     *
     */
    public class Test02 {
    	public static void main(String[] args) {
    		//自动装箱
    		//现在可以不用这样写,编译器会自动帮你生成   原: Integer a = new Integer(100);
    		Integer a = 1000;
    		Integer b = 2000;
    		
    		//自动拆箱
    		//编译器自动改进:int c = new Integer(1500).intValue();
    		int c = new Integer(1500);
    		Integer d = 2000;
    		int e = d;//编译器改进:d.intValue();
    		System.out.println(e);
    		
    		Integer d1 = 1234;
    		Integer d2 = 1234;
    		System.out.println(d1==d2);
    		System.out.println(d1.equals(d2));
    		
    		System.out.println("****************************");
    		
    		//属于[-128,127]之间的数,仍然当做基本数据类型来处理
    		Integer d3 = 123;
    		Integer d4 = 123;
    		System.out.println(d3==d4);
    		System.out.println(d3.equals(d4));
    		
    		System.out.println("****************************");
    		Integer d5 = 128;
    		Integer d6 = 128;
    		System.out.println(d5==d6);
    		System.out.println(d5.equals(d6));
    		
    	}
    }
    

     

    结果显示:
    2000
    false
    true
    ****************************
    true
    true
    ****************************
    false
    true
    

     

    展开全文
  • 自动装箱 和自动拆箱

    2019-01-15 18:41:54
    Integer i=new Integer(2); Integer j=new Integer(2); System.out.println(ij);//比较的是地址 System.out.println(i.equals(j));//equals被重写比较的是数据 ...//在jvm中(-128~127)之间有个常量池 ...
    	Integer i=new Integer(2);
    	Integer j=new Integer(2);
    	System.out.println(i==j);//比较的是地址
    	System.out.println(i.equals(j));//equals被重写比较的是数据
    	//在jvm中(-128~127)之间有个常量池
    	Integer a=127;//Integer a=new Integer(127);	
    	Integer b=127;//Integer b=a;
    	System.out.println(a==b);
    	System.out.println(a.equals(b));
    	
    	Integer a1=128;//自动装箱 //Integer a1=new Integer(128); 
    	Integer b1=128;
    	System.out.println(a1==b1);
    	System.out.println(a1.equals(b1));
    	
    	Integer i2=new Integer(2);
    	Integer j2=new Integer(2);
    	System.out.println(i2+1==j2+1);//自动拆箱 Integer i=new Integer(2); i.intValue()+1;
    	System.out.println(i2.equals(j2));//equals被重写比较的是数据
    
    展开全文

空空如也

1 2 3 4 5 ... 20
收藏数 3,324
精华内容 1,329
关键字:

自动装箱和自动拆箱