【自动装箱以及包装类的缓存】⭐️通过具体案例看下每种包装类的不同结果


目录

前言

一、自动装箱与拆箱(以 Integer 包装类为例)

二、再来看看几个示例

​三、Double ,Float 类型亦是如此吗?

四、补充


前言

        小伙伴们大家好,日常使用业务层方面的代码居多,但也不可忘了基本的一些代码格式以及原理,比如最近看到的一种题型,这里就涉及到了自动装箱的基础知识了

        Integer i = new Integer(10);
        Integer j = 10;
        Integer k = 10;
        System.out.println(i == j);   //false
        System.out.println(k == j);   //true

一、自动装箱与拆箱(以 Integer 包装类为例)

        1、装箱就是自动将基本数据类型转换为包装器类型( int >> Integer),调用Integer.valueOf(int )方法

        2、拆箱就是反过来,将包装器类型转换为基本数据类型,调用了Integer.intValue方法

        3、java并不是一开始就支持自动拆装,查了下是在Java SE5之后才支持该功能

        自动装箱之后写法对比

        Java SE5之前:Integer i = new Integer(10);

        Java SE5之后:Integer i = 10;

二、再来看看几个示例

        1.比如前言中提到的 i 和 j 为什么不相等?

Integer i = new Integer(10)

         创建了一个新的Integer对象,而Integer j = 10; 则会自动装箱,实际上会调用Integer Integer j = 10

        实际上进行了装箱操作,相当于调用了Integer.valueOf(10)                 

        而由于10在缓存范围内,因此会复用缓存中的对象。

i和j虽然表示的是相同的值,但是i和j指向的是不同的对象,所以表达式 i == j 的结果是false

        2.通过new 关键字生成的Integer对象比较

        Integer i = new Integer(127);
        Integer j = new Integer(127);
        System.out.println(i == j);   //false

 ij 分别是通过 new Integer(127) 创建的两个不同的对象,会被强制创建为新的对象,而不是从缓存中获取。即使值相同,但它们在内存中的位置不同,因此比较 i == j 会返回 false

        3.Integer.valueOf 方法缓存的对象大小区间

        Integer k = 10;
        Integer l = Integer.valueOf(10);
        Integer l1 = Integer.valueOf(128);
        System.out.println(k == l);   //true
        System.out.println(k == l1);  //false

Integer k = 10;

Integer l = Integer.valueOf(10);

    这两行代码执行时,都会将值为10的整数赋给Integer对象。在Java中,对于数值范围在-128到127之间的整数,会被缓存起来,所以当你比较 k == l 时,因为10在缓存范围内,它们实际上指向的是同一个对象,所以返回true。

          而当比较 k == l1 时,因为128不在缓存范围内,所以 Integer.valueOf(128) 会创建一个新的Integer对象,与 Integer k = 10; 创建的对象不同,因此返回false。

        来看下 Integer.valueOf 方法内部 ,制定了数值范围如果是在[-128,127]之间,返回IntegerCache缓存中已经存在的对象的引用,否则创建一个新的 Integer对象,所以k 和 l 指向的是同一个对象,k 和 l1 分别指向不同的对象

三、Double ,Float 类型亦是如此吗?

        Double i = 10.0;
        Double j = 10.0;
        Float i1 = 10.0f;
        Float j1 = 10.0f;
        Long i2 = 10l;
        Long j2 = 10l;
        System.out.println(i == j);   //false
        System.out.println(i1 == j1);   //false
        System.out.println(i2 == j2);   //true

         通过结果可以看出,Long 类型之外的都没有缓存的功能

因为为了性能和内存的考虑,只对整数类型的包装类(如Integer、Long等)进行了缓存优化,而没有对浮点数类型的包装类(如Float、Double等)进行缓存,具体分为以下几点。

  1. 整数类型的范围相对较小,而且常常被使用到,因此缓存能够显著提高性能。
  2. 整数类型的对象在程序中经常被频繁使用,缓存能够减少内存的占用和对象的创建次数。
  3. 对于浮点数类型,范围更广,而且通常不像整数类型那样被频繁使用。缓存这些类型可能会导致内存开销过大,而且由于浮点数的精度和计算方式的特殊性,可能会引入更多的问题而不是性能提升。

四、补充

        IntegerCache 类

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

        IntegerCache.cache 是一个长度为 256 的 Integer 数组,用于缓存整数对象。

        IntegerCache.low 和 IntegerCache.high 分别表示缓存的整数范围的下界和上界。                  IntegerCache.cache 中存储了 -128 到 127 之间的整数对象的引用。

        例如,当 i 的值为 10 时,表达式 IntegerCache.cache[10 + (-(-128))] 等价于 IntegerCache.cache[138],表示缓存数组中索引为 138 的位置存储了整数值 10 对应的 Integer 对象。

五、章末

        好了,文章到这里就结束了~ 

  • 17
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

在比萨斜塔吃披萨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值