精华内容
下载资源
问答
  • 主要为大家详细介绍了Java自动拆装箱的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • java自动拆装箱 | Path

    2021-03-14 21:24:12
    ++自动拆装箱的问题引入由于在一开始学习java的时候,”万物皆对象“这种面向对象的看问题方式,时刻围绕在脑海中。因为静态的变量和基本数据类型不属于对象,但是由8种基本数据类型的自动装拆箱解决了基本数据类型...

    +

    +

    +

    +

    +

    +

    所有文章出现的代码,将会出现在我的github中,名字可以根据类全名来找,我在github中的文件夹也会加目录备注。

    +

    +

    自动拆装箱的问题引入

    由于在一开始学习java的时候,”万物皆对象“这种面向对象的看问题方式,时刻围绕在脑海中。因为静态的变量和基本数据类型不属于对象,但是由8种基本数据类型的自动装拆箱解决了基本数据类型不是对象。

    +

    在jdk1.5中引入了自动拆装箱的新特性,在jdk1.5之前,我们想要使用integer类中的方法,我们先要把int变量变成integer类型,可以通过new Integer(intNumber) 或者调用Integer.valueOf(intNumber)方法

    +

    自动装拆箱何时发生?

    在调用方法时把基本数据类型作为参数,但是参数的类型是基本数据类型的包装类时。

    在学习过javaSe基础之后,我们知道通过使用集合框架ArrayList或者Map来添加元素的时候,添加的是Object对象,在这里引入ArrayList.add()的源码:

    +1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11/**

    * Appends the specified element to the end of this list.

    *

    * @param e element to be appended to this list

    * @return true (as specified by {@link Collection#add})

    */

    public boolean add(E e){

    ensureCapacity(size + 1); // Increments modCount!!

    elementData[size++] = e;

    return true;

    }

    +

    对于源码的解读:首先我们来看看参数中的(E e),为什么是E?而不是Object?因为E代表的是元素(集合中存储的是元素),我们平时在泛型中可以看到 >,T 代表的是Type 类,再比如键值对中的Map,K 表示的是Key,V 表示的是Value。E K V 等泛型在使用该参数之前就已经限定好了类型,如果赋值给Object的话,就不用再进行强制类型转换了。

    +

    首先把数组的长度+1,这个操作会导致modCount加一,这个变量的作用就是记录当前数组被操作的次数,然后直接把参数传进来的对象赋值给上一次长度位置的元素。返回true表示添加成功

    +

    当我们调用ArrayList.add()方法的时候,可以直接调用

    +1

    2ArrayList arrayList = new ArrayList();

    arrayList.add(10);

    +

    反编译这段代码:

    +1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13public class AutoboxingTest

    {

    public AutoboxingTest()

    {

    }

    public static void main(String args[])

    {

    ArrayList arrayList = new ArrayList();

    arrayList.add(Integer.valueOf(100));

    }

    }

    +

    可以看到,编译器在编译的时候,检测到arrayList.add()需要的是Integer对象,所以把int类型自动装箱成Integer类型。

    +

    给基本数据类型的包装类赋值为基本数据类型的时候。

    以Integer和int类型的变量作为例子:

    +1

    2

    3

    4

    5

    6public class AutoboxingTest2{

    public static void main(String[] args){

    Integer integer = 10;

    }

    }

    +

    反编译例子:

    +1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12public class AutoboxingTest2

    {

    public AutoboxingTest2()

    {

    }

    public static void main(String args[])

    {

    Integer integer = Integer.valueOf(10);

    }

    }

    +

    什么时候自动装箱不起作用

    例子1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18public class InvalidateAutoboxing{

    public void print(int num){

    System.out.println("i am int !");

    }

    public void print(Integer num){

    System.out.println("i am integer!");

    }

    }

    public class InvalidateAutoboxingTest{

    public static void main(String[] args){

    InvalidateAutoboxing invalidateAutoboxing = new InvalidateAutoboxing();

    invalidateAutoboxing.print(5);

    }

    }

    +

    运行结果:

    +

    20160302225248708.png

    +

    使用自动装箱拆箱需要注意的地方

    循环与自动装箱拆箱1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12public class CirculateAndAutoboxingAndAutounboxing{

    public static void main(String[] args){

    Integer sum = 0;

    for (int i = 0; i < 200; i++) {

    sum += i;

    }

    }

    }

    +

    反编译:

    +1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15public class CirculateAndAutoboxingAndAutounboxing

    {

    public CirculateAndAutoboxingAndAutounboxing()

    {

    }

    public static void main(String args[])

    {

    Integer sum = Integer.valueOf(0);

    for(int i = 0; i < 200; i++)

    sum = Integer.valueOf(sum.intValue() + i);

    }

    }

    +

    反编译代码解读:由于sum是Integer类型,但是sum+=i 需要sum先自动拆箱成int类型(调用intValue()方法),进行相加之后,再自动装箱成Integer类型把结果赋给sum。

    +

    Integer.valueOf源码解析:

    +1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20/**

    * Returns a Integer instance representing the specified

    * int value.

    * If a new Integer instance is not required, this method

    * should generally be used in preference to the constructor

    * Integer(int), as this method is likely to yield

    * significantly better space and time performance by caching

    * frequently requested values.

    *

    * @param i an int value.

    * @return a Integer instance representing i.

    * @since 1.5

    */

    public static Integer valueOf(int i){

    final int offset = 128;

    if (i >= -128 && i <= 127) { // must cache

    return IntegerCache.cache[i + offset];

    }

    return new Integer(i);

    }

    +

    首先我们在源码说明中看到了该构造器缓存经常使用的数据以减少内存的使用和提高效率,Integer把缓冲区的上限脚标设置成128,如果传进来的数据i在-128~127之中,直接返回缓冲区中的IntegerCache.cache[i + 128] 位中的元素

    +

    IntegerCache的源码解读:

    +1

    2

    3

    4

    5

    6

    7

    8

    9

    10private static class IntegerCache{

    private IntegerCache(){}

    static final Integer cache[] = new Integer[-(-128) + 127 + 1];

    static {

    for(int i = 0; i < cache.length; i++)

    cache[i] = new Integer(i - 128);

    }

    }

    +

    IntegerCache是Integer的内部类,并且内部数组的上限为256元素,在这个内部类中使用了静态代码块(在类加载的时只执行一次),把-128~127都缓存在数组中。所以以后调用的时候就可以直接返回Integer对象,而不用return new Integer(i); Integer Short Long的缓冲数组是一样的,但是Character的范围为0~127,Double和Float没有缓冲数组

    +

    话又说回来,刚刚我们在分析循环与自动装拆箱的使用需要注意:当参与的数值不在缓存的范围内,会产生大量的对象,这样会产生很多垃圾对象,增加GC的工作压力。

    +

    自动装拆箱与三元运算符造成的空指针异常(NPE)1

    2

    3

    4

    5

    6

    7

    8

    9public class AutounboxingWithConditionalOperator{

    public static void main(String[] args){

    HashMap hashMap = new HashMap();

    Boolean b = (hashMap != null ? hashMap.get("test") : false);

    }

    }

    +

    运行:

    +

    20160302233303149.png

    +

    如果在Map中添加了test这条数据:

    +1

    2

    3

    4

    5

    6

    7

    8

    9

    10public class AutounboxingWithConditionalOperator{

    public static void main(String[] args){

    HashMap hashMap = new HashMap();

    hashMap.put("test", true);

    Boolean b = (hashMap != null ? hashMap.get("test") : false);

    System.out.println(b);

    }

    }

    +

    运行:

    +

    20160302233610988.png

    +

    再反编译刚刚NPE异常的代码:

    +1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13public class AutounboxingWithConditionalOperator

    {

    public AutounboxingWithConditionalOperator()

    {

    }

    public static void main(String args[])

    {

    HashMap hashMap = new HashMap();

    Boolean b = Boolean.valueOf(hashMap == null ? false : ((Boolean)hashMap.get("test")).booleanValue());

    }

    }

    +

    下面是hashMap.get(key)方法的说明:

    ++

    Returns the value to which the specified key is mapped,

    +

    or null if this map contains no mapping for the key.

    +

    +

    由上面可以看出,由于Map.get(key)方法,如果没有指定的数据,返回的是null。

    +

    再由于三元运算符有如下定义:

    ++

    The type of a conditional expression is determined as follows:

    +

    1、If the second and third operands have the same type (which may be the null type), then that is the type of the conditional expression.

    +

    2、If one of the second and third operands is of primitive type T, and the type of the other is the result of applying boxing conversion (§5.1.7) to T, then the type of the conditional expression is T.

    +

    3、If one of the second and third operands is of the null type and the type of the other is a reference type, then the type of the conditional expression is that reference type.

    +

    +

    译文:

    +

    三元运算符的类型由以下情况决定:

    +

    1、如果第二和第三个操作结果拥有同样类型(这个类型可能为null),那么这个类型就是该三元运算符的结果类型

    +

    2、如果第二个操作和第三个操作结果其中一个的结果类型为基本数据类型,另外一个操作结果为可以装箱转换成与前面一种类型一致的包装类,那么这个三元运算符的运算结果类型为基本数据类型,即把包装类拆装。

    +

    3、如果在第二、三个操作结果中,有一个为null类型,另外一个为引用类型,那么这个三元运算符的表达式为引用类型。

    +

    综上所述,对于上面出现的情况,对于一个操作结果为基本类型,另外一个为包装类型的三元运算符表达式来说,为了避免NEP的产生,可以通过把它们变成同样类型(参考三元运算符定义的第一条)。

    +

    一点小思考

    从上面的例子中我们可以看见,java中的基本数据类型是不属于对象的,虽然它们有对应的包装类,可是从上面我们反编译或者从其对应的包装类中对应的源码我们可以看见,它们依然坚持不把基本数据类型当作对象来看待,而不像C#那么“纯”,我想可能是开发者考虑到变量在栈中存储,但是对象在堆中存储,涉及到对象就要涉及到垃圾回收,但是在栈中只要函数弹栈,就释放了空间了,可能也怕加重垃圾回收器的压力。毕竟垃圾回收不是程序员能控制的,我们的开始只是通过更了解JVM来更好的分配空间,为了更好的符合垃圾回收的规律,来让垃圾回收更高效。

    +

    参考资料:

    +

    +

    +

    +

    展开全文
  • java中的自动拆装箱

    2021-02-28 12:11:06
    一:是什么java的自动拆装箱,是从jdk1.5之后被引入的,java中的类型分为基本类型和引用类型,而自动拆装箱,可以让基本类型和对应的包装类,无缝转换。先拿最基本的来看。public class UntoBoxing {public static ...

    一:是什么

    java的自动拆装箱,是从jdk1.5之后被引入的,java中的类型分为基本类型和引用类型,而自动拆装箱,可以让基本类型和对应的包装类,无缝转换。先拿最基本的来看。

    public class UntoBoxing {

    public static void main(String[] args) {

    int i = new Integer(1);

    Integer i2 = 10;

    }

    }

    二:为什么

    先说结论:自动拆装箱是编译器的功劳,相当于一个语法糖,在编译成class字节码文件期间,编译器解语法糖,变成正常的字节码。

    public class UntoBoxing

    {

    public UntoBoxing()

    {

    }

    public static void main(String args[])

    {

    int i = (new Integer(1)).intValue();

    Integer i2 = Integer.valueOf(10);

    }

    }

    上图是我们通过反编译工具反编译来的代码,

    1.当我们给基本类型赋值对应的包装类时,会自动调用包装类的intValue()方法,返回一个基本类型的值。

    2.当我们给引用类型赋值基本类型时,会调用Integer的静态方法valueOf(),返回一个引用类型的对象。

    三:什么时候会发生

    1.赋值

    如上,在给基本类型和对应的包装类相互赋值的时候,编译器就自动进行了自动拆装箱操作。

    2.方法调用传入参数的时候

    这个的原理基本同上,在调用方法,入栈时,发生拆装箱操作。

    3.被操作符操作的时候

    Integer integer = new Integer(1);

    int i = integer + 1;

    四:需要注意的问题

    1.比较值的问题

    int和integer类型,互相比较值时,jdk内的Integer类也会有相应的操作。

    int i1 = 3;

    Integer i2= 3;    //编译器解语法糖,变为Integer.valueOf(3);

    Integer i3= 3;    //编译器解语法糖,变为Integer.valueOf(3);

    System.out.println(i1==i2); //输出true,编译器会解语法糖,表达式变为 i1 == i2.intValue();结果为true

    System.out.println(i2== i3); //输出true

    上图唯一需要注意的一点,就是i2 == i3,为什么会输出true?两个引用类型,使用==比较,不是应该比较地址值的么,那这个输出结果,表明这两个引用了同一个堆中的Integer对象?

    答案就在Integer类中,我们查看Integer类的valueOf()方法

    public static Integer valueOf(inti) {if (i >= IntegerCache.low && i <=IntegerCache.high)    //从cache里查找传入的i是否在缓存的范围内,如果在缓存内,那么直接从cache中返回,否则新建。return IntegerCache.cache[i + (-IntegerCache.low)];return newInteger(i);

    }

    上图是integer的valueof方法体,原来,在IntegerCache(Integer里面的静态内部类)的low(-128)和high(默认127,可以通过java.lang.Integer.IntegerCache.high定义)之间的值,就会从IntegerCache里面取,相当于一个缓存了128到127的所有integer的数组,那么当调用Integer.valueOf()方法时,会从这里面查找,这样就能解释了为什么==也会是true,因为他们本身就是从IntegerCache里面的同一个Integer对象。

    2.性能问题

    我们看一个例子

    Integer i = 1;for (int j = 0; j < 10000; j++) {

    i+=1;

    }

    上面代码,表面上看去没什么问题,一个正常的+1操作,循环1w次,那么我们反编译后,看看编译器是怎么处理这个的。

    Integer i= Integer.valueOf(1);for (int j = 0; j < 10000; j++)

    i= Integer.valueOf(i.intValue() + 1);

    我们来看一下怎么变成上面的这个样子的.

    a:i+=1;

    b:i = i + 1;  由于i是引用类型,i+1会变成 i.intValue() + 1;

    c:i = i + 1;   将一个基本类型的int值传递给一个Integer引用类型,编译器解语法糖,转换为Integer.valueOf(),参数为i.intValue()+1;

    分析可得,Integer类型的++操作,会频繁创建Integer类型的对象!!!堆中的新生代会有大量的无用对象,会加快miniorGC,我们看下图,我们在运行之后,显示的执行System.gc()方法,可以看到回收了大量的内存,这些内存就是我们在循环中自己创建的,如果在一些比较注重性能的系统中,这样的操作造成的后果也是相对严重的。

    299bc66d5033645059fd5d88af5e6e81.png

    3.重载问题

    之前我们说过,在方法中的参数,会自动拆装箱,但是如果有两个方法,会重载,如下图所示,那么会调用哪一个呢?

    72c6b8354d4ea2a446ffac7ccd8d2276.png

    可以看出,方法重载中,当调用方面对Object和int时,是不会自动拆装箱的,或者Object的优先级比自动拆装箱高。

    4.空指针问题

    基本类型,即使我们不初始化赋值,编译器也会有默认值(int类型赋值为0,boolean类型赋值为false),但是如果是包装类型,是不会有默认值的,所以直接调用,会有空指针异常。

    这一点也经常被我们用来判断一个值到底是没有初始化,还是就是0。比如客户的年龄,到底是0岁,还是没有输入客户年龄,使用int类型就不能判断出来,但是使用Integer类型就可以区别开来。

    总结

    基本类型和引用类型各有利弊,当我们使用基本类型的时候,对象会有默认值,对象也被存储在栈中(方法内使用),调用/释放更快,节省了资源,但是并不符合java的面向对象的思想;

    引用类型更符合java面向对象的思想,可以为空,但是牺牲了性能,所以在实际使用中,要根据具体情况判断。

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

    2021-03-13 01:00:30
    java自动自动拆装箱最近在看Effective-Java-3rd发现其中介绍一个自动拆装箱影响程序的性能问题。自动拆装箱是java 1.5开始新增的功能,它允许程序员混合基本类型和包装类型,根据需要自动装箱和拆箱。但是在性能上面...

    java自动自动拆装箱

    最近在看Effective-Java-3rd发现其中介绍一个自动拆装箱影响程序的性能问题。

    自动拆装箱是java 1.5开始新增的功能,它允许程序员混合基本类型和包装类型,根据需要自动装箱和拆箱。但是在性能上面还是有较大的差别的。看下面的例子:

    public static void main(String[] args) {

    long startTime=System.currentTimeMillis();

    System.out.println(sum());

    System.out.println("共耗时:"+(System.currentTimeMillis()-startTime)+"毫秒");

    }

    private static long sum() {

    //这个比较性能较差

    //Long sum = 0L;

    //这个性能较好

    long sum = 0L;

    for (long i = 0; i <= Integer.MAX_VALUE; i++)

    sum += i;

    return sum;

    }

    运行结果

    累加值为:2305843008139952128

    共耗时:872毫秒

    而采用包装类进行相加时,例子如下

    public class LongMain {

    public static void main(String[] args) {

    long startTime=System.currentTimeMillis();

    System.out.println("累加值为:"+sum());

    System.out.println("共耗时:"+(System.currentTimeMillis()-startTime)+"毫秒");

    }

    private static long sum() {

    //这个比较性能较差

    Long sum = 0L;

    //这个性能较好

    //long sum = 0L;

    for (long i = 0; i <= Integer.MAX_VALUE; i++)

    sum += i;

    return sum;

    }

    }

    运行结果如下:

    累加值为:2305843008139952128

    共耗时:12337毫秒

    可以看出包装类与非包装类之间的运行时间相差将近14倍,究其原因,是每次包装类型的Long在进行sum+=1时,都会创建一个新的对象,所以导致性能下降。

    结论:

    从性能的方面考虑,基本类型优于包装类,优先使用基本类型,应提防意外的自动装箱。

    展开全文
  • 自动拆装箱

    2020-09-02 17:13:15
    自动拆装箱分为拆箱和装箱。 拆箱:把包装类转换为对应的基本数据类型 装箱: 把基本数据类型转换为对应的包装类 ps:基本数据类型对应的包装类见五、扩展 二、原理 所有的包装类都有多个相同方法,其中有一个为value...

    自动拆装箱

    一、定义

    自动拆装箱分为拆箱和装箱。
    拆箱:把包装类转换为对应的基本数据类型
    装箱: 把基本数据类型转换为对应的包装类
    ps:基本数据类型对应的包装类见五、扩展
    

    二、原理

    所有的包装类都有多个相同方法,其中有一个为valueOf(); 这个方法就是将基本数据类型转换为对应的包装类。
    同时有一个类似的方法为???Value(), 其中???代表八种基本数据类型;  这个方法就是将包装类转换为对应的基本数据类型。 
    

    三、应用

    1、集合
     	  集合是不接受存放基本数据类型的,但在实际开发中,一个Integer的集合是可以直接add一个int变量的。在这个过程就是自动装箱。  
    
         List<Integer> list = new ArrayList<>();
     	 int i = 1;
     	 list.add(i); 
     	 //这一步实际上是
     	 list.add(Integer.valueOf(i));
    
    2、比较
    	  我们经常用包装类与基本数据类型进行比较运算,得到一个布尔值,再进行不同的业务逻辑。这个过程是先将包装类转换为基本数据类型再进行比较。
    
              Integer a = 1;
     		  System.Out.println(a > 2 ? "a大":"a小");
     		  //实际
     		  System.Out.println(a.intValue(a) > 2 ? "a大":"a小");
    
    3、运算
    	  两个包装类进行四则运算时,会将包装类转换为基本数据类型再运算
    
              Integer a = 1;
     		  Integer b = 2;
     		  System.Out.println(a+b);
     		  //实际过程
     	      Integer a = Integer.valueOf(1);
     	      Integer b = Integer.valueOf(2);
    	      System.Out.println(a.intValue()+b.intValue());
    
    还有一些其它的应用,就不一一列举。
    

    四、问题

    自动拆装箱使用中也会有些问题需要注意
    1、有些场景会进行自动拆装箱,由于自动拆箱,如果包装类对象为null,那么自动拆箱时就有可能抛出NPE(空指针异常)。
    2、如果一个for循环中有大量拆装箱操作,会浪费很多资源。
    3、包装类进行比较,在-128-127可以用==,这个范围之外需要使用equals进行比较,在不确定范围时,避免出现异常最好使用equals
    

    五、扩展

    基本数据类型对应的包装类
    int      --->   Integer
    byte     --->   Byte
    long     --->   Long
    float    --->   Float
    boolean  --->   Boolean
    short    --->   Short
    char     --->   Character
    double   --->   Double
    
    展开全文
  • 什么是Java中的自动拆装箱

    万次阅读 多人点赞 2018-09-03 12:47:37
    本文主要介绍Java中的自动拆箱与自动装箱的有关知识。 1、基本数据类型 基本类型,或者叫做内置类型,是Java中不同于类(Class)的特殊类型。它们是我们编程中使用最频繁的类型。 Java是一种强类型语言,第一次...
  • } 自动拆装箱与缓存 Java SE的自动拆装箱还提供了一个和缓存有关的功能,我们先来看以下代码,猜测一下输出结果: public static voidmain(String... strings) { Integer integer1= 3; Integer integer2= 3;if ...
  • 文章目录JDK.8自动拆装箱1.构造方法2.自动拆装箱3.Integer基本方法4.Integer与int之间的==关系 JDK.8自动拆装箱 1.构造方法 package ContainerLoading; /** * Integer应用类型的构造方法 * public Integer(int ...
  • 背景有Java基础的同学都知道Java中有Primitive Type(原始类型),比如int、short。...为了方便大家写代码,JDK 5以后引入了自动拆装箱的机制. 比如对于函数:add(Integer a)我们在调用的时候,传一个Intege...
  • 一文读懂自动拆装箱

    2019-07-29 13:36:00
    本文主要介绍Java中的自动拆箱与自动装箱的有关知识。基本数据类型基本类型,或者叫做内置类型,是Java中不同于类(Class)的特殊类型。它们是我们编程中使用最频繁的类...
  • 主要介绍了Java三目运算中隐藏的自动拆装箱,本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • java自动拆装箱

    2019-04-29 10:10:31
    public class Solution { public static void main(String[] args) { Integer a = new Integer(3); Integer b = 3; // 将3自动装箱成Integer类型,new一个Integer对象 Integer c = 3; // 如果整型...
  • 自动拆装箱在Java5(就是Java1.5,后边改了命名)时被引入,自动装箱就是Java自动将基础类型值转换成对应的包装类对象,比如将int的变量转换成Integer对象,这个过程叫做装箱,反之将Integer对象转换成int类型值,这个...
  • 在学习并发的过程中,用“Boolean bool = true”的自动装箱方式初始化了两个对象锁去锁两块代码,结果运行的时候出现了竞争等待,调试了一下发现两个锁变量指向的是同一个对象,由此可见我对自动拆装箱的机制想的太...
  • Java的自动拆装箱

    2019-06-02 14:24:08
    什么是自动拆装箱? Java 语言支持的 8 中基本数据类型是: 整型:byte short int long 浮点型:float double 布尔型:boolean 字符型:char 自动装箱是 Java 编译器在基本数据类型和对应的对象包装类型之间...
  • 主要给大家介绍了关于Java基础教程之基本类型数据类型、包装类及自动拆装箱的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 什么是自动拆装箱

    千次阅读 2019-06-02 10:07:15
    自动装箱和拆箱,就是基本类型和引用类型的相互转换。...为了优化这一问题,在jdk5中引入了自动拆装箱的机制。 但是使用自动拆装箱时,需要了解他的机制,否则会出现难以捕捉的bug。 比如int和integer之间的缓存...
  • 经过排查代码发现这个坑是在三目运算符与自动拆装箱 这一块。 第一眼看代码,初步分析因该是 detectInfo 如果为null 0f 会自动装箱赋值给score , 如果不为null ,detectInfo .getScore() 的值赋值给score。即使为...
  • 本文主要介绍Java中的自动拆箱与自动装箱的有关知识。基本数据类型基本类型,或者叫做内置类型,是Java中不同于类(Class)的特殊类型。它们是我们编程中使用最频繁的类型。Java是一种强类型语言,第一次申明变量必须...
  • 摘在看《深入理解Java虚拟机》一书时看到的问题,关于Java编译器在进行解语法糖时对于自动拆装箱做出的行为,有时会造成误解或者歧义,所以在此总结一下Java中自动拆装箱的陷阱先提出一个问题: 看下面代码, 分别输出...
  •  4)函数返回值自动拆装箱:当函数定义时,指定了函数返回值是包装类,则return 一个基本数据类型值时,就会自动装箱;如果定义的函数返回值是基本数据类型时,return一个包装类对象会自动拆箱。   三:自动拆...
  • JAVA自动拆装箱

    千次阅读 多人点赞 2016-02-23 11:19:33
    自动装箱自动拆箱为程序员提供了很大的方便,而在实际的应用中,自动装箱与拆箱也是使用最广泛的特性之一。自动装箱自动拆箱其实是Java编译器提供的一颗语法糖(语法糖是指在计算机语言中添加的某种语法,这种...
  • Integer与Integer比较的时候,由于直接赋值的时候会进行自动装箱,那么这里就需要注意两个问题,一个是-128的整数,将会直接缓存在IntegerCache中,那么当赋值在这个区间的时候,不会创建新的Integer对象,而是从...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,695
精华内容 5,078
关键字:

自动拆装箱