精华内容
下载资源
问答
  • 基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。java语言规范中说道:在许多情况下包装与解包装是由编译器自行完成的(在这种情况下包装成为装箱,解包装称为拆箱
  • java基础--06(自动装箱拆箱

    千次阅读 多人点赞 2019-02-11 16:40:27
    1.自动装箱,自动拆箱 1.自动装箱,自动拆箱 装箱就是自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。 java的数据类型: 自动装箱: 最主要的就是Integer b=a;这...

    目录

     

    1.自动装箱,自动拆箱


    1.自动装箱,自动拆箱

         装箱就是自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。

         java的数据类型:

         

     

    自动装箱:

    最主要的就是Integer b=a;这行代码执行了什么?其实这就是自动装箱的过程,上面程序在执行Integer b=a;的时候调用了Integer.valueOf ( int i ) 方法,`Integer b=a; 这段代码等同于:Integer b=Integer.valueOf ( a ) 。

    自动拆箱:

    其实 int a=b,这段代码等价于:int a=b.intValue(),来看看inValue()方法到底是什么,下面是源码:、

            

    看看相关的题目:

     

    代码1好理解,a和b指向的是堆的两块不同的区域,所以他们是不相等的,输出fasle。

    代码2也好理解,他是一个自动装箱的过程,会调用Integer.valueOf ( int i ) 方法,所以,他们c,d都不会创建新的对象,而是直接从常量池中拿。所以他们都是一样的,输出true.

    代码3也是哥自动装箱的过程,调用Integer.valueOf ( int i )方法,判断不在缓存中拿,所以会在堆上创建新的对象,比较的时候当然是fasle.

    代码4,int g=59,首先明白这个59是存储在哪里的?由于他是基本的数据类型,所以它是存在栈中的,Integer h=new Integer(59);这个会在堆中就创建一个对象存储的是59,但是由于代码执行到g==h的时候,这时一个是基本类型一个包装类型,他们相比较,h会发生自动拆箱的过程。即调用intValue()方法返回一个int类型,基本类型就是只比较数值,所以输出true。

      接下来再看:

      这个输出会是什么?

    public class Test4 {
        public static void main(String[] args) {
            Double i1 = 100.0;
            Double i2 = 100.0;
            Double i3 = 200.0;
            Double i4 = 200.0;
    
            System.out.println(i1 == i2);
            System.out.println(i3 == i4);
        }
    }

     其实只要看看Double的valueOf()方法的实现就知道了:

    所以他会输出false,false

    注意,Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。

       Double、Float的valueOf方法的实现是类似的。

    好,接下来再看一个题目:这个输出会是什么?

     

     

     首先第一个没有什么疑问,c和d都来自缓存,所以相等输出true.

     第二个e,f的输出也没什么疑问,都会创建新的对象,所以不等,输出false.

     第三个可能刚刚看的时候有点懵逼,但是仔细想想就知道答案,首先会执行的是a+b,首先a和b是包装类型,是对象,他们是不可能相加的,所以先要执行拆箱的操作将a,b拆成基本数据类型再做相加的操作,完了之后与c进行比较,c是包装类型,所以c也会自动拆箱进行比较,这儿可能有疑问就是为什么不是自动装箱成包装类型去比较,而是包装类型进行了拆箱操作呢?

       看这个例子:

       

      如果最后是装箱操作的话,输出的就是false,所以最后他不是装箱而是拆箱操作。

      所以最后输出true.

    第四个的其实就是equals()方法和==的区别,equals()和==其实一样,判断的是两个对象是否相等,但是Integer对equals()方法进行了重写,他比较的就是值,他不会进行类型转换。所以执行a+b的时候依然会有一个拆箱的过程,但是指向equals的时候她会有一个装箱的过程。所以输出的是true.

    第五个和第三个有点类似,都是转化为基本的数据类型,然后比较数值,所以他们数值是相等的,返回的是true.

    第六个也是先拆箱,然后相加运算,但是请注意这个和上一个直接==不同,上面可以拆箱比较数值,而这个equals()方法里面是Object类型的数据,也就是说他要传一个引用类型的参数,所以a+b会装箱成Integerr类型的数据,但是g是Long类型。类型不同就比较不了了。

    第七个,对于a+h,先自动触发拆箱,就变成了int类型和long类型相加,这个会触发类型晋升,结果是long类型的,然后会触发装箱过程,就变成Long了。因此比较结果是true。

     

    在项目中,当我们使用对象的比较的时候一般会用到Objects类,

     

    常用方法:

    1.public static boolean equals(Object a,Object b):比较对象a和对象b是否相等.
      *比较2个对象是否相等,底层依赖对象重写的equals的方法,如果没有重写,则使用Object的equals()

    2.public static <T> T requireNonNull(T obj):检查对象obj不为null,如果为null,则抛出空指针异常,否则返回obj本身.
      *可以判断对象是否是空对象.限制参数不能为空.

    3.public static boolean nonNull(Object obj):判断对象是否为null,不为返回true,否则返回false

    4.public static boolean isNull(Object obj):和nonNull()相反.
     

    参考博客:

       https://www.cnblogs.com/dolphin0520/p/3780005.html

       https://blog.csdn.net/u013309870/article/details/70229983

      https://blog.csdn.net/ijwddd/article/details/80557759

     

    展开全文
  • 主要介绍了Java包装类及自动装箱拆箱,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 1.自动装箱拆箱的定义装箱就是自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。Java中的数据类型分为两类:一类是基本数据类型,另一类是引用数据类型。如下图:由上可知Java...

    1.自动装箱与拆箱的定义

    装箱就是自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。

    Java中的数据类型分为两类:一类是基本数据类型,另一类是引用数据类型。如下图:

    这里写图片描述

    由上可知Java中的基本数据类型有八种分别是:int(4字节) byte(1字节) short(2字节) long(8字节) float (4字节) double(8字节) char(2字节) boolean(1byte)基本数据类型不是对象,不能使用对象的方法。将基本数据类型转换为对象就是自动装箱的过程。下面是基本数据类型与封装器类之间对应的关系。

    简单类型二进制位数封装器类
    int32Integer
    byte8Byte
    long64Long
    float32float
    double64Double
    char16Character
    boolean1Boolean

    自动装箱

    先看下面这段代码:

    public static void main(String[] args) {
            // TODO Auto-generated method stub
            int a=3;
            //定义一个基本数据类型的变量a赋值3
            Integer b=a;
            //b是Integer 类定义的对象,直接用int 类型的a赋值    
            System.out.println(b);
            //打印结果为3
        }

    上面的代码中 Integer b=a; 非常的奇怪,一个对象怎么赋值成了基本数据类型的变量,其实这就是自动装箱的过程,上面程序在执行Integer b=a;的时候调用了Integer.valueOf ( int i ) 方法,`Integer b=a; 这段代码等同于:Integer b=Integer.valueOf ( a ) 。下面是对 Integer.valueOf ( int i ) 方法简化后的源码:

    public static Integer valueOf(int i) {       
            if (i >= -128 && i <= 127)
                return IntegerCache.cache[i + 127];
                //如果i的值大于-128小于127则返回一个缓冲区中的一个Integer对象
            return new Integer(i);
            //否则返回 new 一个Integer 对象
        }

    可以看到Integer.valueOf ( a )其实是返回了一个Integer的对象。因此由于自动装箱的存在Integer b=a 这段代码是没有毛病的。其实更简化的来写可以这样:Integer b=3,同样这段代码等价于:Integer b=Integer.valueOf (3 ) 。

    自动拆箱

    先看下面的这段代码:

    public static void main(String[] args) {
            // TODO Auto-generated method stub
    
            Integer b=new Integer(3);
            //b为Integer的对象
            int a=b;
            //a为一个int的基本数据类型
            System.out.println(a);
            //打印输出3。
        }

    上面的代码:int a=b,很奇怪,怎么把一个对象赋给了一个基本类型呢?其实 int a=b,这段代码等价于:int a=b.intValue(),来看看inValue()方法到底是什么,下面是源码:

    public int intValue() {
            return value;
        }

    这个方法很简单嘛,就是返回了value值,然而value又是什么,继续找到了一个代码:

    public Integer(int value) {
            this.value = value;
        }
    

    原来value,就是定义 Integer b=new Integer(3) ; 赋的值。所以上面的代码其实是这样的:

    public static void main(String[] args) {
            // TODO Auto-generated method stub
    
            Integer b=new Integer(3);
            //b为Integer的对象
            int a=b.intValue();
            //其中b.intValue()返回实例化b时构造函数new Integer(3);赋的值3。
            System.out.println(a);
            //打印输出3。
        }

    相关题目

    自动装箱和拆箱已经解决了,看看下面的代码输出什么:

    public static void main(String[] args) {        
            //1
            Integer a=new Integer(123);
            Integer b=new Integer(123);
            System.out.println(a==b);//输出 false
    
            //2 
            Integer c=123;
            Integer d=123;  
            System.out.println(c==d);//输出 true
    
            //3
            Integer e=129;
            Integer f=129;
            System.out.println(e==f);//输出 false
            //4
            int g=59;
            Integer h=new Integer(59);
            System.out.println(g==h);//输出 true
        }

    上面的三段代码:代码1 输出为 true 还是比较好理解的:如下图:

    这里写图片描述

    a,b是栈中对象的引用分别指向堆中两个不同的对象,而 a==b 这条语句就是判断 a , b在堆中指向的对象是不是同一个,因此 代码1输出false。

    然而代码2中的输出为什么会是true呢?由上面的自动装箱知道

        Integer c=123;
        Integer d=123;  
    

    不也是生成了两个对象 c 和 d 吗? 为什么输出结果却为true。这个其实跟自动装箱有关,再来看一下自动装箱的源代码:

    public static Integer valueOf(int i) {       
            if (i >= -128 && i <= 127)
                return IntegerCache.cache[i + 127];
                //如果i的值大于-128小于127则返回一个缓冲区中的一个Integer对象
            return new Integer(i);
            //否则返回 new 一个Integer 对象
        }

    上面的这段代码中:IntegerCache.cache[i + 127]; 又是什么?下面是简化后的源码:

     private static class IntegerCache {
    
            static final Integer cache[];
            //定义一个Integer类型的数组且数组不可变
            static {  
            //利用静态代码块对数组进行初始化。                     
                cache = new Integer[256];
                int j = -128;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);
            }
    
      //cache[]原来是一个Integer 类型的数组(也可以称为常量池),value 从-128到127,
        public static Integer valueOf(int i) {   
            if (i >=-128 && i <= 127)        
                return IntegerCache.cache[i + (-IntegerCache.low)];
                //如果装箱时值在-128到127之间,之间返回常量池中的已经初始化后的Integer对象。
            return new Integer(i);
            //否则返回一个新的对象。
        }
    }

    由上面的代码很好理解,原来IntegerCache 类在初始化的时候,生成了一个大小为 256 的integer 类型的常量池,并且integer.val 的值从-128-127,当我们运行 Integer c=a ;时,如果 -128<=a<=127时,不会再生成新的integer对象,直接从常量池中找到对应的已经初始化后的对象。当 a<-128||a>127时会生成一个新的对象。因此不难理解代码2为什么会输出true了。因为 c 和 d指向的是同一个对象,并不是生成了两个不同对象。同样不难理解代码3为什么会输出 false 。但是代码4中明明g指向的是栈中的变量,而h指向的是堆中的对象,为什么 g==h 是true,这就是自动拆箱,g==h 这代码执行时其实是:g==h.IntValue(),而h.IntValue()=59,所以两边其实是两个 int 在比较。

    总结

    上面讲解了int基本类型的自动装箱和拆箱,其实int byte short long float double char boolean 这些基本类型的自动装箱和拆箱过程都是差不多的。

    简单一句话:装箱就是自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。

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

    2018-03-28 15:44:31
    而基本类型包装类作为引用类型的一种却可以计算,原因在于,Java”偷偷地”自动地进行了对象向基本数据类型的转换。 相对应的,引用数据类型变量的值必须是new出来的内存空间地址值,而我们可以将一个基本类型的值...

    在需要的情况下,基本类型与包装类型可以通用。有些时候我们必须使用引用数据类型时,可以传入基本数据类型。

    比如:

    基本类型可以使用运算符直接进行计算,但是引用类型不可以。而基本类型包装类作为引用类型的一种却可以计算,原因在于,Java”偷偷地自动地进行了对象向基本数据类型的转换。

    相对应的,引用数据类型变量的值必须是new出来的内存空间地址值,而我们可以将一个基本类型的值赋值给一个基本类型包装类的引用。原因同样在于Java偷偷地自动地进行了基本数据类型向对象的转换。

    • 自动拆箱:对象转成基本数值

    • 自动装箱:基本数值转成对象

    Integeri = 4;//自动装箱。相当于Integeri = Integer.valueOf(4);

    i= i + 5;//等号右边:将i对象转成基本数值(自动拆箱)i.intValue() + 5; 加法运算完成后,再次装箱,把基本数值转成对象。


    • 自动装箱(byte常量池)细节的演示

    当数值在byte范围之内时,进行自动装箱,不会新创建对象空间而是使用医来已有的空间。

    Integera = new Integer(3);

    Integerb = new Integer(3);

    System.out.println(a==b);//false

    System.out.println(a.equals(b));//true


    System.out.println("---------------------");

    Integerx = 127;

    Integery = 127;

    //jdk1.5自动装箱时,如果数值在byte范围之内,不会新创建对象空间而是使用原来已有的空间。

    System.out.println(x==y);//true

    System.out.println(x.equals(y));//true

    展开全文
  • 其实, 自动装箱拆箱机制只是一个语法糖, 只能发生在编译器编译阶段, 在Java虚拟机运行class文件的时候就不能自动装箱拆箱了; 比如, 在编译阶段比如发现一个应该是int数据的地方, 但是如果传入了一个Integer对象, ...

    今天在写GUI的时候遇到了一个问题, 我在写ActionListener的时候写出了类似这样的代码:

    		JComboBox<Integer> aComboBox = new JComboBox<>();
            aComboBox.addActionListener(event->{
                text.setFont(new Font("Serif",Font.PLAIN,aComboBox.getSelectedItem()));
            });
    

    发现报错, 提示告诉我是在setFont传入最后一个参数的时候传入的是一个Integer而不是一个int, 但是按照Java的自动装箱拆箱机制, 在此处的Integer应该会自动拆箱调用intValue方法变成int, 但是并没有, 查询资料之后发现:

    其实, 自动装箱拆箱机制只是一个语法糖, 只能发生在编译器编译阶段, 在Java虚拟机运行class文件的时候就不能自动装箱拆箱了;

    比如, 在编译阶段比如发现一个应该是int数据的地方, 但是如果传入了一个Integer对象, 此时编译器会自动使用intValue方法把它自动拆箱, 但是这只是一个语法糖, 在Java虚拟机运行阶段是不能使用的, 所以这里在运行时才会调用ActionListener, 如果使用了getSelectedItem就需要做强制类型转化成(int)aComboBox.getSelectedItem()才可以;
    修改代码之后:

    text.setFont(new Font("Serif",Font.PLAIN,(int)aComboBox.getSelectedItem()));
    
    展开全文
  • 自动装箱、拆箱不只是体现在以上的例子,在方法接收参数、对象设置参数时都能自动装箱拆箱。 需要注意的是,关于 Integer,-128 ~ 127 会有缓存,对比这个范围的值的对象是一个坑,这个在阿里巴巴规范中也有提及。...
  • JVM之自动装箱拆箱 提问:jvm中如何进行进行装箱拆箱操作? 装箱拆箱 先写个示例代码: package com.imooc.firstappdemo.jvm; public class TofuCaiInteger { public static void main(String[] args) { ...
  • 最近在学习一本关于java虚拟机的书,其中有一段关于自动装箱陷阱的示例代码如下: public static void main(String[] args) { Integer a = 1; Integer b = 2; Integer c = 3; Integer d = 3; Integer e = 321;...
  • 本文转自:https://blog.csdn.net/u013309870/article/details/702299831.自动装箱拆箱的定义装箱就是自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。Java中的数据类型分为两...
  • //8、 } Integer 的自动拆箱和装箱 自动拆箱自动装箱是 JDK1.5 以后才有的功能,也就是java当中众多的语法糖之一,它的执行是在编译期,会根据代码的语法,在生成class文件的时候,决定是否进行拆箱和装箱动作。...
  • 因为以前只知道 Java 为一些基础数据类型与对应的包装器类型之间提供了自动装箱拆箱机制,而并不知这机制的具体实现方法是怎么样的,正好学习一下。 用命令 `javap -c Test` 将以上代码编译出的 Test.class ...
  • 关于Java自动装箱拆箱的面试题

    千次阅读 2019-01-27 18:11:45
    答案如上注释部分,核心考察点就是上道题的答案,即 java 1.5 开始的自动装箱拆箱机制其实是编译器自动完成的替换,装箱阶段自动替换为了 valueOf 方法,拆箱阶段自动替换为了 xxxValue 方法。对于 Integer 类型的 ...
  • 自动装箱拆箱

    2019-05-27 11:54:00
    自动装箱:基本数值自动直接转成对象 l自动装箱(byte常量池)细节的演示 当数值在byte范围之内时,进行自动装箱,不会新创建对象空间而是使用已有的空间。 public class Demo04 { public static void main...
  • 自动装箱拆箱欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
  • Java 8 自动装箱效率影响测试 测试完毕之后的结论:   1. 自动装箱对于少量的, 简单的运算造成的效率影响不大   2. 自动装箱对于单纯的赋值操作影响不大 测试代码如下. public void test() { /** * 首先什么...
  • Java自动装箱与自动拆箱(包装类)

    千次阅读 多人点赞 2019-06-15 10:18:39
    时候,系统可以 自动将它“包装”为相应的包装类的实例程序需要对象时, 如果给的只是一个基本类型的值, 系统会将它自动装箱为包装类的实例达到的效果: 有了自动装箱之后, 基本类型的值可以当成对象用—— 其实是...
  • 装箱和拆箱 装箱:将基本数据类型转换成封装类型。 拆箱:将封装类型转换成...下面来看看自动装箱(拆箱)和显示装箱(拆箱)的例子: Integer a1 = 3; // 自动装箱 Integer a2 = Integer.valueOf(3); // 显示装箱 i...
  • 所谓装箱拆箱就是指基本数据类型与包装类型的自动相互转换。他的目的就是可以简化代码,提升编程体验。 在JavaScript语言中,也是有这样的概念的。 我们知道,JS中有基本数据类型与object类型之分,比如 // 基本数据...
  • Java自动装箱拆箱

    2020-03-24 16:18:46
    自动拆箱与装箱介绍 自动装箱拆箱是 Java 1.5 引入的新特性,是一种语法糖。 在此之前,我们要创建一个值为 10 的 Integer 对象,只能写作: Integer value = new Integer(10); 而现在,我们可以更方便地写为: ...
  • /** * 自动装箱拆箱 */ public class AutoBoxOrUnBox { public static void main(String[] args) { Integer i = 6; int j = i; } } 自动装箱与拆箱的原理: 我们通过反编译工具的代码: package autoBox; public ...
  • 自动装箱和自动拆箱实现原理!

    千次阅读 2019-03-06 15:58:41
    什么是自动装箱拆箱 自动装箱就是Java自动将原始类型值转换成对应的对象,比如将int的变量转换成Integer对象,这个过程叫做装箱,反之将Integer对象转换成int类型值,这个过程叫做拆箱。因为这里的装箱和拆箱是...
  • 专栏原创出处:github-源笔记文件 ,...一、为什么要自动装箱拆箱 基础数据类型不是对象的,或者说基础数据类型不是 Object 的子类。所以不支持基础数据类型与 Object 之间的强制转型。 JDK 5 后出现了泛型,但是泛...
  • Java的数据类型 和装箱拆箱机制 数据类型 第一类整数型(byte short int long) Java各整数型有固定的表示范围和字段长度 ,不会受到不同操作系统的影响,这点确保了java程序的可移植性。 Java中整数型的数据默认值...
  • 自动装箱 拆箱

    2019-04-18 09:19:55
    装箱:将基本类型用它对应的引用类型包装起来。 拆箱:将包装类型转换为基本数据类型。 详见(转载):https://www.cnblogs.com/dolphin0520/p/3780005.html
  • 什么是自动装箱,自动拆箱 自动装箱就是自动将基本数据类型转换为包装器类型; 自动拆箱就是自动将包装器类型转换为基本数据类型。 基本数据类型 int、short、long、float、double、byte、char、boolean。 包装器...
  • 装箱: 将基本类型用它们对应的引用类型包装起来 拆箱: 将包装类型转换为基本数据类型

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,677
精华内容 17,870
关键字:

自动装箱拆箱