精华内容
下载资源
问答
  • 自动装箱

    2020-05-20 10:15:39
    自Java 1.5起,所有Java开发人员都可以使用自动装箱功能。嗯,我可能太乐观了。 至少所有开发人员都应该可以使用自动装箱。 毕竟,在ORACLE页面上有一个很好的教程。 自动装箱是Java编译器在需要时自动从原始类型...

    自Java 1.5起,所有Java开发人员都可以使用自动装箱功能。嗯,我可能太乐观了。 至少所有开发人员都应该可以使用自动装箱。 毕竟,在ORACLE页面上有一个很好的教程。

    自动装箱是Java编译器在需要时自动从原始类型创建代码创建对象的代码时的现象。 例如,您可以编写:

    Integer a = 42;

    它将自动生成将值int 42放入Integer对象的JVM代码。 编译器为我们做到这一点真是太好了,以至于一段时间后,程序员往往会忘记它背后的复杂性,而我们有时会碰壁。

    例如,我们有double.classDouble.class 它们都是对象(作为一个类,每个类本身都是permgen中的对象,或者只是后permgen版本的JVM中的堆)。 这两个对象都是Class类型。 而且,由于Java 1.5都属于Class<Double>类型。

    如果两个对象具有相同的类型,那么它们也必须是赋值兼容的。 似乎是一个显而易见的陈述。 如果您有对象O a和对象O b则可以指定a = b

    查看代码,但是我们可能会发现遗忘而不是显而易见:

    public class TypeFun {
        public static void main(String[] args) {
            // public static final Class<Double>   TYPE = (Class<Double>)Class.getPrimitiveClass("double");
            System.out.println("Double.TYPE == double.class: " + (Double.TYPE == double.class));
            System.out.println("Double.TYPE == Double.class: " + (Double.TYPE == Double.class));
            System.out.println("double.class.isAssignableFrom(Double.class): " + (double.class.isAssignableFrom(Double.class)));
            System.out.println("Double.class.isAssignableFrom(double.class): " + (Double.class.isAssignableFrom(double.class)));
        }
    }

    结果:

    Double.TYPE == double.class: true
    Double.TYPE == Double.class: false
    double.class.isAssignableFrom(Double.class): false
    Double.class.isAssignableFrom(double.class): false

    这意味着Double的原始对是double.class (不足为奇)。 即使不能从另一个分配一个。 我们至少可以查看其中之一的来源。 Double类的源代码位于RT.jar中,并且是开源的。 在那里,您可以看到:

    public static final Class<Double>	TYPE = (Class<Double>) Class.getPrimitiveClass("double");

    为什么使用奇怪的Class.getPrimitiveClass("double")而不是double.class 那是Double类型的原始对。

    答案并不简单,您可以深入研究Java和JVM的细节。 由于double不是一个类,因此实际上没有比double.class了。 但是,您仍然可以在Java源代码中使用此文字,并且Java语言,编译器和运行时具有很强的约束力。 编译器知道Double类定义了一个名为TYPE的字段,该字段表示其原始类型。 每当编译器在源代码中看到double.class ,它都会生成JVM代码Double.TYPE (尝试一下,然后使用javap解码生成的代码!)。 因此,RT的开发人员无法编写:

    public static final Class<Double>	TYPE = double.class;

    进入Double类的源代码。 它将编译为等效的代码:

    public static final Class<Double>	TYPE = TYPE;

    那么自动装箱如何进行? 来源:

    Double b = (double)1.0;

    结果:

    0: dconst_1      
             1: invokestatic  #2                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
             4: astore_1

    但是,如果我们替换两个“ d”字母:

    double b = (Double)1.0;

    然后我们得到:

    0: dconst_1      
             1: invokestatic  #2                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
             4: invokevirtual #3                  // Method java/lang/Double.doubleValue:()D
             7: dstore_1

    进食可以解释很多事情。 double.class类和Double.class类的实例不分配兼容。 自动装箱解决了这个问题。 Java 4很久以前了,幸运的是,我们忘记了它。

    您的作业:重读具有“类”类型和相应原始类型参数的方法时,重读与自动装箱相关的事情。

    翻译自: https://www.javacodegeeks.com/2014/09/autoboxing.html

    展开全文
  • 自动装箱和自动拆箱 自Java 1.5起,所有Java开发人员都可以使用自动装箱功能。嗯,我可能太乐观了。 至少所有开发人员都应该可以使用自动装箱。 毕竟,在ORACLE页面上有一个很好的教程。 自动装箱是指Java编译器在...
    自动装箱和自动拆箱

    自动装箱和自动拆箱

    自Java 1.5起,所有Java开发人员都可以使用自动装箱功能。嗯,我可能太乐观了。 至少所有开发人员都应该可以使用自动装箱。 毕竟,在ORACLE页面上有一个很好的教程。

    自动装箱是指Java编译器在需要时自动从原始类型创建用于创建对象的代码的现象。 例如,您可以编写:

    Integer a = 42;

    它将自动生成将值int 42放入Integer对象的JVM代码。 编译器为我们做到这一点真是太好了,以至于一段时间之后,程序员往往会忘记它背后的复杂性,而我们有时会碰壁。

    例如,我们有double.classDouble.class 它们都是对象(作为一个类,每个类本身都是permgen中的对象,或者只是JVM后permgen版本中的堆上的对象)。 这两个对象都是Class类型的。 而且,由于Java 1.5都属于Class<Double>类型。

    如果两个对象具有相同的类型,那么它们也必须是分配兼容的。 似乎是一个显而易见的陈述。 如果您有对象O a和对象O b则可以指定a = b

    查看代码,但是我们可能会发现遗忘而不是显而易见:

    public class TypeFun {
        public static void main(String[] args) {
            // public static final Class<Double>   TYPE = (Class<Double>)Class.getPrimitiveClass("double");
            System.out.println("Double.TYPE == double.class: " + (Double.TYPE == double.class));
            System.out.println("Double.TYPE == Double.class: " + (Double.TYPE == Double.class));
            System.out.println("double.class.isAssignableFrom(Double.class): " + (double.class.isAssignableFrom(Double.class)));
            System.out.println("Double.class.isAssignableFrom(double.class): " + (Double.class.isAssignableFrom(double.class)));
        }
    }

    结果:

    Double.TYPE == double.class: true
    Double.TYPE == Double.class: false
    double.class.isAssignableFrom(Double.class): false
    Double.class.isAssignableFrom(double.class): false

    这意味着Double的原始对是double.class (不足为奇)。 即使不能从另一个分配一个。 我们至少可以查看其中之一的来源。 Double类的源代码位于RT.jar中,并且是开源的。 在那里,您可以看到:

    public static final Class<Double>	TYPE = (Class<Double>) Class.getPrimitiveClass("double");

    为什么使用奇怪的Class.getPrimitiveClass("double")而不是double.class 那就是Double类型的原始对。

    答案并不简单,您可以深入研究Java和JVM的细节。 由于double不是一个类,因此实际上没有比double.class了。 不过,您仍然可以在Java源代码中使用此文字,并且Java语言,编译器和运行时具有很强的约束力。 编译器知道Double类定义了一个名为TYPE的字段,该字段表示其原始类型。 每当编译器在源代码中看到double.class ,它都会生成JVM代码Double.TYPE (尝试一下,然后使用javap解码生成的代码!)。 因此,RT的开发人员无法编写:

    public static final Class<Double>	TYPE = double.class;

    进入Double类的源代码。 它将编译为等效的代码:

    public static final Class<Double>	TYPE = TYPE;

    那么自动装箱如何进行? 来源:

    Double b = (double)1.0;

    结果:

    0: dconst_1      
             1: invokestatic  #2                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
             4: astore_1

    但是,如果我们替换两个“ d”字母:

    double b = (Double)1.0;

    然后我们得到:

    0: dconst_1      
             1: invokestatic  #2                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
             4: invokevirtual #3                  // Method java/lang/Double.doubleValue:()D
             7: dstore_1

    进食可以解释很多事情。 double.class类和Double.class类的实例不分配兼容。 自动装箱解决了这个问题。 Java 4很久以前了,幸运的是,我们忘记了它。

    您的作业:重读具有“类”类型和相应原始类型参数的方法时,重读与自动装箱相关的事情。

    翻译自: https://www.javacodegeeks.com/2014/09/autoboxing.html

    自动装箱和自动拆箱

    展开全文
  • 自动装箱和拆箱 自Java 1.5以来,所有Java开发人员都可以使用自动装箱功能。嗯,我可能太乐观了。 至少所有开发人员都应该可以使用自动装箱。 毕竟,在ORACLE页面上有一个很好的教程。 自动装箱是指Java编译器在...

    自动装箱和拆箱

    自Java 1.5以来,所有Java开发人员都可以使用自动装箱功能。嗯,我可能太乐观了。 至少所有开发人员都应该可以使用自动装箱。 毕竟,在ORACLE页面上有一个很好的教程。

    自动装箱是指Java编译器在需要时自动从原始类型创建用于创建对象的代码的现象。 例如,您可以编写:

    Integer a = 42;

    它将自动生成将值int 42放入Integer对象的JVM代码。 编译器为我们做到这一点真是太好了,以至于一段时间后,程序员往往会忘记它背后的复杂性,而我们有时会碰壁。

    例如,我们有double.classDouble.class 它们都是对象(作为一个类,每个类本身都是permgen中的对象,或者只是后permgen版本的JVM中的堆)。 这两个对象均为Class类型。 而且,由于Java 1.5都属于Class<Double>类型。

    如果两个对象具有相同的类型,那么它们也必须是赋值兼容的。 似乎是一个显而易见的陈述。 如果您有对象O a和对象O b则可以指定a = b

    查看代码,但是我们可能会发现遗忘而不是显而易见:

    public class TypeFun {
        public static void main(String[] args) {
            // public static final Class<Double>   TYPE = (Class<Double>)Class.getPrimitiveClass("double");
            System.out.println("Double.TYPE == double.class: " + (Double.TYPE == double.class));
            System.out.println("Double.TYPE == Double.class: " + (Double.TYPE == Double.class));
            System.out.println("double.class.isAssignableFrom(Double.class): " + (double.class.isAssignableFrom(Double.class)));
            System.out.println("Double.class.isAssignableFrom(double.class): " + (Double.class.isAssignableFrom(double.class)));
        }
    }

    结果:

    Double.TYPE == double.class: true
    Double.TYPE == Double.class: false
    double.class.isAssignableFrom(Double.class): false
    Double.class.isAssignableFrom(double.class): false

    这意味着Double的原始对是double.class (不足为奇)。 即使不能从另一个分配一个。 我们至少可以查看其中之一的来源。 Double类的源代码位于RT.jar中,并且是开源的。 在那里,您可以看到:

    public static final Class<Double>	TYPE = (Class<Double>) Class.getPrimitiveClass("double");

    为什么使用奇怪的Class.getPrimitiveClass("double")而不是double.class 那就是Double类型的原始对。

    答案并不简单,您可以深入研究Java和JVM的细节。 由于double不是一个类,因此实际上没有像double.class这样的类。 但是,您仍然可以在Java源代码中使用此文字,并且Java语言,编译器和运行时具有很强的约束力。 编译器知道Double类定义了一个名为TYPE的字段,该字段表示其原始类型。 每当编译器在源代码中看到double.class ,它都会生成JVM代码Double.TYPE (尝试一下,然后使用javap解码生成的代码!)。 因此,RT的开发人员无法编写:

    public static final Class<Double>	TYPE = double.class;

    进入Double类的源代码。 它将编译为等效的代码:

    public static final Class<Double>	TYPE = TYPE;

    那么自动装箱如何进行? 来源:

    Double b = (double)1.0;

    结果:

    0: dconst_1      
             1: invokestatic  #2                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
             4: astore_1

    但是,如果我们替换两个“ d”字母:

    double b = (Double)1.0;

    然后我们得到:

    0: dconst_1      
             1: invokestatic  #2                  // Method java/lang/Double.valueOf:(D)Ljava/lang/Double;
             4: invokevirtual #3                  // Method java/lang/Double.doubleValue:()D
             7: dstore_1

    进食可以解释很多事情。 double.class类和Double.class类的实例不分配兼容。 自动装箱解决了这个问题。 Java 4很久以前了,幸运的是我们忘记了它。

    您的作业:重读带有“类”类型和相应原始类型参数的方法时,重读与自动装箱相关的事情。

    翻译自: https://www.javacodegeeks.com/2014/09/autoboxing.html

    自动装箱和拆箱

    展开全文
  • 自动装箱和拆箱是一个老生常谈的问题了,今天我们谈一下我对这两个概念的理解。一、自动装箱java中一共有八种基本类型的数据,对于这些基本类型的数据都有一个对应的包装器类型。比如int——Integer等;在javaSE5...

    自动装箱和拆箱是一个老生常谈的问题了,今天我们谈一下我对这两个概念的理解。

    一、自动装箱

    java中一共有八种基本类型的数据,对于这些基本类型的数据都有一个对应的包装器类型。比如int——Integer等;

    在javaSE5之前,如果需要对实现一个Integer对象必须如下:

    Integer a = new Integer(10);

    从JavaSE5开始就有了自动装箱的特性,如下:

    //装箱

    Integer i = 10;

    Integer i= Integer.valueOf(10);

    //拆箱

    int n = i;

    那么上面的装箱和拆箱是如何实现的呢?

    装箱的时候会调用Integer.vlaueOf方法,拆箱的时候会自动调用intValue方法。

    那么什么时候装箱和拆箱呢?

    1、对象初始化时候装箱。如:Integer i = 10;

    2、使用表达式的时候拆箱。如:i+i

    3、基本类型赋值时候拆箱。如:int a = i;

    4、使用equals方法时候装箱。如:i.equals(表达式)。

    猜一下下面的结果:

    Integer a = 1;

    Integer b= 2;

    Integer c= 3;

    Integer d= 3;

    Integer e= 321;

    Integer f= 321;

    Long g= 3L;

    Long h= 2L;

    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));//a+b中a和b都是Integer类型,会先触发自动拆箱,变成int类型。然后触发自动装箱,变成Integer类型。类型不一样false

    System.out.println(g.equals(a+b));

    System.out.println(g.equals(a+h));

    结果:

    true

    false

    true

    true

    true

    false

    true

    展开全文
  • 一、前言Java自动装箱和自动拆箱是JDK5.0版本提供的新特性,所以在JDK5.0后的版本中都可以使用,之前的版本则不支持该特性。理解自动装箱和自动拆箱需要先对java中的8种原始数据类型和相对应的封装类有所了解。二、8...
  • 自动装箱定义:将一个原始数据类型赋值给相应封装类的变量在JDK1.5版本以后,经常使用的是下面的方法来定义一个Integer对象.Integer num1 = 127;num1为一个Integer类型的引用,127为java中的基础数据类型,这种将一个...
  • java自动装箱Autoboxing in java was introduced in Java 1.5. Autoboxing and unboxing is a convenient way to auto transform primitive data type to it’s corresponding java wrapper classes and vice versa....
  • 自动装箱的定义就是 基本数据类型赋值给包装类型, 拆箱则相反。 Integer integer =122;// 自动装箱 intnum = integer;//自动拆箱 想看一下源码是怎么完成自动装箱和拆箱的。 发现第一行代码自动装箱走的方法是 ...
  • 基本数据类型,如int,float,double,boolean,char,byte,不具备对象的特征,不能调用方法。...自动装箱拆箱:将包装类对象转换成基本类型的值Integer j=new Integer(8);int m=j.intValue();//手动拆箱in...
  • 概述自JDK1.5开始, 引入了自动装箱/拆箱这一语法糖, 它使程序员的代码变得更加简洁, 不再需要进行显式转换。基本类型与包装类型在某些操作符的作用下, 包装类型调用valueOf()方法将原始类型值转换成对应的包装类对象...
  • 前言一开始想学学自动拆箱和自动装箱是被这个名字吸引到,听上去好像很高端的样子,其实认真看一下,自动拆箱、自动装箱就是很简单的内容。自动拆箱和自动装箱Java为每种基本数据类型都提供了对应的包装器类型。举个...
  • 自动装箱与自动拆箱

    2020-07-15 20:31:11
    1.自动装箱,自动拆箱 1.自动装箱,自动拆箱      装箱就是自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。      java的数据类型:   &...
  • 自动装箱 autoBoxing

    万次阅读 2017-05-11 14:23:42
    自动装箱是java 1.5 引入的新技术,主要是为了解决 原始类型和对象的转换, 也就是 原始类型 byte short int long float double boolean char 与 包装对象 Byte Short Integer Long Float Double Boolean ...
  • JDK5的新特性自动装箱:把基本类型转换为包装类类型自动拆箱:把包装类类型转换为基本类型注意一个小问题:在使用时,Integer x = null;代码就会出现NullPointerException(空指针异常)建议先判断是否为null,然后再...
  • 什么是自动装箱和拆箱自动装箱就是Java自动将原始类型值转换成对应的对象,比如将int的变量转换成Integer对象,这个过程叫做装箱,反之将Integer对象转换成int类型值,这个过程叫做拆箱。因为这里的装箱和拆箱是自动...
  • 根据自动装箱控制系统的机械结构和工作原理,利用STM32F103系列单片机和伺服电机,设计了控制系统硬件电路原理图,完成了对自动装箱系统码垛机械手的控制,实现了自动装箱系统对小型电器产品包装盒的抓取、运送、...
  • 自动拆箱和自动装箱

    2019-11-24 23:25:38
    自动拆箱和自动装箱 自动装箱 把基本数据类型转换为对应的包装类类型 自动拆箱 把包装类类型转换为对应的基本数据类型
  • 自动装箱 自动拆箱

    2019-07-09 20:41:00
    自动装箱 自动拆箱是JDK 1.5的新特性。 说道自动装箱和拆箱,首先我们需要知道基本数据类型包装类。 java提供了四类八种基本数据类型,但是有些需求,靠基本数据类型无法满足我们的需求,或者是不方便。例如做一些...
  • 自动装箱和自动拆箱

    2019-07-09 21:39:24
    什么是自动装箱和自动拆箱 基本数据类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。自动装箱是java编译器在java原生类型和对应的对象包装类型上做的自动转换。例如,把int 装换成 ...
  • 什么是自动装箱拆箱基本数据类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。一般我们要创建一个类的对象实例的时候,我们会这样:Class a = new Class(parameter);当我们创建一个Integer...
  • Java自动装箱性能

    2021-01-20 03:39:18
    有了自动装箱,你可以写如下的代码  Character boxed = 'a';  char unboxed = boxed;  编译器自动将它转换为  Character boxed = Character.valueOf('a');  char unboxed = boxed.charValue();  然而,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,234
精华内容 3,693
关键字:

自动装箱