Java基础之基本数据类型封装类的缓存

已于 2022-03-28 12:04:34 修改
阅读量1k 收藏 2
点赞数
文章标签： java
于 2022-03-28 11:27:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hnjcxy/article/details/123787209
版权
本文详细介绍了Java中Byte、Short、Character、Integer、Long、Boolean等封装类型的缓存机制，包括缓存范围及如何通过特定方法修改这些缓存范围。此外，还展示了不同类型变量间的比较方式，并提供了具体的测试代码。
摘要由CSDN通过智能技术生成

1、Java中基本数据类型byte、short、char、int、long、float、double、boolean有对应的封装类型：Byte、Short、Character、Integer、long、Float、Double，Boolean其中Byte、Short、Character、Integer、Long、Boolean都实现了常量池缓存。Byte、Short、Character、Integer、Long通过静态内部Cache类来实现一定范围（下面列出缓存范围）内的数据缓存，而Boolean通过两个静态常量TRUE、FALSE来实现数据缓存。

  • Byte类缓存范围：[-128,127] 共256个值。
  • Short类缓存范围：[-128,127] 共256个值。
  • Character类缓存范围：[0,127] 共128个值。
  • Integer类默认缓存范围：[-128,127] 共256个值，可以通过修改VM参数-XX:AutoBoxCacheMax=200 即可修改缓存上限到200
  • Long类缓存范围：[-128,127] 共256个值。
  • Boolean类就缓存两个值：true、false。
2、装箱和拆箱过程：
装箱：调用封装类 valueOf(x) 方法；
拆箱：调用封装类的 xxValue() 方法。

3、测试
测试前说明：
==对于基本数据类型和对象的比较含义是不同的。对于基本数据类型：“==” 比较的是基本数据类型的数值；对于对象：“==” 比较的是对象在内存中的内存地址。
byte、short、char类型计算后会自动转成整型类型int。

（1）Byte


    static void testByte(){
        System.out.println("Byte类型：");
        Byte i1 = 127;
        Byte i2 = 127;
        Byte i3 = 0;
        Byte i4 = new Byte("127");
        Byte i5 = new Byte("127");
        Byte i6 = new Byte("0");

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为数值在[-128,127]的范围内，使用常量池缓存中的127

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池Byte对象127，i4指向堆中Byte对象127

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型byte做加法运算，
        //计算结果是整型的127，所以最终是基本数据类型的值作比较;（byte、short、char类型计算后会自动转成整型类型int）
        System.out.println("127=i5+i6 " + (127 == i5 + i6)); //true
        System.out.println("byte计算后，转换类型为："+ myGetType(i5 + i6));  // int

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型byte做加法运算，计算结果是整型的127；
        // i1与基本数据类型127比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); //true

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型byte做加法运算，计算结果是整型的127；
        // i4与基本数据类型127比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); //true

        /* Byte类中有缓存静态内部类ByteCache；缓存范围：-128~127，共256（cache.length）个值
        private static class ByteCache {
            private ByteCache(){}

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

            static {
                for(int i = 0; i < cache.length; i++)
                    cache[i] = new Byte((byte)(i - 128));
            }
        }
         */
    }

（2）Short


    static void testShort(){
        System.out.println("Short类型：");
        Short i1 = 127;
        Short i2 = 127;
        Short i3 = 0;
        Short i4 = new Short("127");
        Short i5 = new Short("127");
        Short i6 = new Short("0");
        Short i1New = 128;
        Short i2New = 128;

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为数值在[-128,127]的范围内，使用常量池缓存中的127

        System.out.println("i1New=i2New " + (i1New == i2New));  //false 超过缓存范围，创建新对象了

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池对象127，i4指向堆中对象127

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型short做加法运算，
        //计算结果是整型的127，所以最终是基本数据类型的值作比较;（byte、short、char类型计算后会自动转成整型类型int）
        System.out.println("127=i5+i6 " + (127 == i5 + i6)); //true
        System.out.println("short计算后，转换类型为："+ myGetType(i5 + i6));  // int

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型short做加法运算，计算结果是整型的127；
        // i1与基本数据类型127比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); //true

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型short做加法运算，计算结果是整型的127；
        // i4与基本数据类型127比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); //true

        /* Short类中有缓存静态内部类ShortCache；缓存范围：-128~127，共256（cache.length）个值
        private static class ShortCache {
            private ShortCache(){}

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

            static {
                for(int i = 0; i < cache.length; i++)
                    cache[i] = new Short((short)(i - 128));
            }
        }
         */
    }

（3）Character


    static void testChar(){
        System.out.println("Character类型：");
        Character i1New72 = 72;
        Character i1 = 40; //表示字符'('
        Character i2 = 40;
        Character i3 = 32;
        Character i4 = new Character('(');//字符'('的十进制码点值是40
        Character i4New72 = new Character('H');//字符'H'的十进制码点值是72
        Character i5 = new Character('(');
        Character i6 = new Character(' '); //空格的十进制码点值是32
        Character i1New = 128;
        Character i2New = 128;
        Character i1New1 = 127;
        Character i2New2 = 127;

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为数值在[0,127]的范围内，使用常量池缓存中的40

        System.out.println("i1New=i2New " + (i1New == i2New));  //false 超过缓存范围，创建新对象了

        System.out.println("i1New1=i2New2 " + (i1New1 == i2New2));  //true 没有超过缓存范围，使用常量池缓存中的值

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池Character对象40，i4指向堆中Character对象40

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型char做加法运算，
        //计算结果是整型的72，所以最终是基本数据类型的值作比较;（byte、short、char类型计算后会自动转成整型类型int）
        System.out.println("72=i5+i6 " + (72 == i5 + i6) +" 因为：i5+i6= " + (i5 + i6)); //true
        System.out.println("char计算后，转换类型为："+ myGetType(i5 + i6));  // int

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型char做加法运算，计算结果是整型的72；
        // i1New72与基本数据类型72比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i1New72=i2+i3 " + (i1New72 == i1 + i3)); //true
        System.out.println("i4New72=i5+i6 " + (i4New72 == i5 + i6)); //true

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，即拆箱后的基本数据类型char做加法运算，计算结果是整型的72；
        // i4New72与基本数据类型72比较的时候也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i4=i5+i6 " + (i4New72 == i5 + i6) +" 因为：i5+i6= " + (i5 + i6)); //true

        Character c = '(';
        System.out.println("字符‘(’的码点值：" + (int)c); //40

        /* Caracter类中有缓存静态内部类CharacterCache；缓存范围：0~127，共128（cache.length）个值
        private static class CharacterCache {
            private CharacterCache(){}

            static final Character cache[] = new Character[127 + 1];

            static {
                for (int i = 0; i < cache.length; i++)
                    cache[i] = new Character((char)i);
            }
        }
         */
    }

（4）Integer


    static void testInt(){
        System.out.println("Boolean类型：");
        Integer i1 = 127;
        Integer i2 = 127;
        Integer i3 = 0;
        Integer i4 = new Integer(127);
        Integer i5 = new Integer(127);
        Integer i6 = new Integer(0);
        Integer i1New = 128;
        Integer i2New = 128;

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为数值在[-128,127]的范围内，使用常量池缓存中的127

        System.out.println("i1New=i2New " + (i1New == i2New));  //false 超过缓存范围，创建新对象了

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池对象127，i4指向堆中对象127

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型int，所以最终是基本数据类型的值作比较
        System.out.println("127=i5+i6 " + (127 == i5 + i6)); //true

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型int；i1与基本数据类型比较的时候也会自动拆箱
        System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); //true

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型int；
        //i4与i5+i6的基本数据类型int结果比较时，i4也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); //true

        /* Integer类中有缓存静态内部类IntegerCache；默认缓存范围：-128~127，共256（cache.length）个值；
            但是可通过 java.lang.Integer.IntegerCache.high 修改高位值,例如：设置vm参数 -XX:AutoBoxCacheMax=200 即
            可修改缓存上限为200
        private static class IntegerCache {
            static final int low = -128;
            static final int high;
            static final Integer cache[];

            static {
                // high value may be configured by property
                int h = 127;
                String integerCacheHighPropValue =
                    sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
                if (integerCacheHighPropValue != null) {
                    try {
                        int i = parseInt(integerCacheHighPropValue);
                        i = Math.max(i, 127);
                        // Maximum array size is Integer.MAX_VALUE
                        h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                    } catch( NumberFormatException nfe) {
                        // If the property cannot be parsed into an int, ignore it.
                    }
                }
                high = h;

                cache = new Integer[(high - low) + 1];
                int j = low;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);

                // range [-128, 127] must be interned (JLS7 5.1.7)
                assert IntegerCache.high >= 127;
            }

            private IntegerCache() {}
        }
         */
    }

Idea2021通过配置VM options修改Integer缓存上限，具体配置参考：

Idea2021.3.2 设置项目运行参数配置_hnjcxy的博客-CSDN博客Idea2021.3.2 设置运行参数配置:Program arguments 、 Environment variables 和 VM options。1、点击Run -> Edit Configurations2、在打开的窗口可以设置 Program arguments 和 Environment variables 参数，如果需要设置VM参数，请看第三步设置VM参数。设置Program arguments参数时，多个参数中间用空格分开，如："22" "33" "44"。.https://blog.csdn.net/hnjcxy/article/details/123791208

（5）Long


    static void testLong(){
        System.out.println("Long类型：");
        Long i1 = 127L;
        Long i2 = 127L;
        Long i3 = 0L;
        Long i4 = new Long(127L);
        Long i5 = new Long(127L);
        Long i6 = new Long(0);
        Long i1New = 128L;
        Long i2New = 128L;

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为数值在[-128,127]的范围内，使用常量池缓存中的127L

        System.out.println("i1New=i2New " + (i1New == i2New));  //false 超过缓存范围，创建新对象了

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池对象127L，i4指向堆中对象127L

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型long，所以最终是基本数据类型的值作比较
        System.out.println("127L=i5+i6 " + (127L == i5 + i6)); //true

        //因为 i2+i3 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型long；i1与基本数据类型比较的时候也会自动拆箱
        System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); //true

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本数据类型long；
        //i4与i5+i6的基本数据类型long结果比较时，i4也会自动拆箱，所以最终是基本数据类型的值作比较
        System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); //true

        /* long类中有缓存静态内部类ByteCache；缓存范围：-128~127，共256（cache.length）个值
        private static class LongCache {
            private LongCache(){}

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

            static {
                for(int i = 0; i < cache.length; i++)
                    cache[i] = new Long(i - 128);
            }
        }
         */

    }

（6）Boolean


    static void testBool(){
        System.out.println("Boolean类型：");
        Boolean i1 = true;
        Boolean i2 = true;
        Boolean i4 = new Boolean("true");
        Boolean i5 = new Boolean("true");

        System.out.println("i1=i2 " + (i1 == i2));  //true 因为i1、i2使用常量池缓存中的true

        System.out.println("i1=i4 " + (i1 == i4)); //false 因为i1指向常量池对象true，i4指向堆中对象true，所以两个对象地址不同

        System.out.println("i4=i5 " + (i4 == i5)); //false 因为i4和i5是堆中两个对象，比较的是两个对象地址

        //因为 i5 与常量true比较时，会自动拆箱为基本数据类型boolean，所以最终比较的是值，不是对象地址
        System.out.println("true=i5+i6 " + (true == i5)); //true

    }

（7）Double 和 Float 没有缓存


    static void testDouble(){
        System.out.println("Double类型：");
        Double i1 = 127.0;
        Double i2 = 127.0;
        Double i3 = 0.0;
        Double i4 = new Double(127.0);
        Double i5 = new Double(127.0);
        Double i6 = new Double(0);

        System.out.println("i1=i2 " + (i1 == i2));  //false 没有缓存，是两个不同的Double类型对象

        //因为 i2+i3 做算术运算+时，会自动拆箱再做加法，所以结果是拆箱后的基本类型double数值127.0，i1与基本数据类型比较时，
        // 也需要拆箱成基本数据类型，最后比较两个基本数据类型127.0的值是否相等
        System.out.println("i1=i2+i3 " + (i1 == i2 + i3)); //true

        System.out.println("i1=i4 " + (i1 == i4)); //false 没有缓存，是两个不同的Double类型对象

        System.out.println("i4=i5 " + (i4 == i5)); //false 没有缓存，是两个不同的Double类型对象

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是基本数据类型double;最后比较两个基本数据类型127.0的值是否相等
        System.out.println("127.0=i5+i6 " + (127.0 == i5 + i6)); //true
        System.out.println("Double计算后，类型为："+ myGetType(i5 + i6));  // int

        //因为 i5+i6 做算数运算+时，会自动拆箱再做加法，所以结果是基本数据类型double；i4与i5+i6的基本数据类型结果比较时，
        // i4也会自动拆箱成基本数据类型double，最后是比较基本数据类型的值，而不是比较封装类对象地址
        System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); //true


    }
测试中用到的判断基本数据类型的方法：
//判断类型
    public static String myGetType(Object o) {
        String type = o.getClass().getSimpleName();
        if ("Integer".equals(type)) {
            return String.valueOf(Integer.TYPE);
        } else if ("Long".equals(type)) {
            return String.valueOf(Long.TYPE);
        } else if ("Float".equals(type)) {
            return String.valueOf(Float.TYPE);
        } else if ("Double".equals(type)) {
            return String.valueOf(Double.TYPE);
        } else if ("Short".equals(type)) {
            return String.valueOf(Short.TYPE);
        } else if ("Byte".equals(type)) {
            return String.valueOf(Byte.TYPE);
        } else if ("Character".equals(type)) {
            return String.valueOf(Character.TYPE);
        } else if ("Boolean".equals(type)) {
            return String.valueOf(Boolean.TYPE);
        }
        return "非基本数据类型！";
    }

hnjcxy
关注
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java中的包装类和基础类型数据比较大小的关系
plazilan的博客
08-18 1079
1.概念 为了方便、快捷的去操作基本类型数据，java提供基本类型对应的包装类。只能创建出包装类的对象就能提供操作基本类型的数据的便捷性。 2.运用规则 1.int和int之间，用比较，肯定为true。基本数据类型没有equals方法 2.int和Integer比较，Integer会自动拆箱， 和 equals都肯定为true 3.int和new Integer比较，Integer会自动拆箱，调用intValue方法, 所以 == 和 equals都肯定为true 4.Integer和Integer比较的
Java 中常用缓存Cache机制的实现
11-08
Java 中常用缓存Cache机制的实现
java基本类型有缓冲区类型的有_Java的基本数据类型
weixin_39534759的博客
02-13 227
1、Java的基本数据类型都有哪些各占有几个字节？2、String是基本数据类型吗？String是引用类型，底层使用char数组实现的。3、short s1 = 1; s1 = s1 + 1;有错吗？short s1 = 1; s1 += 1有错吗；前者不正确，后者正确。对于short s1 = 1; s1 = s1 + 1；由于1是int类型，因此s1+1运算结果也是int型，需要强制类型转换才...
【JavaSE】Java基本数据类型缓存池
最新发布
weixin_42904738的博客
09-09 666
前面所示的Integer缓存池其实就是Integer的一个静态内部类。
关于封装类的缓存
03-30 592
http://howtodoinjava.com/2013/03/06/object-initialization-best-practices-internal-caching-in-wrapper-classes/
基本数据类型的包装类的缓存问题
Toughb的博客
10-23 242
包装类的缓存 包装类缓存的问题： 整型、char类型所对应的包装类，在自动装箱时，对于-128~127之间的值会进行缓存处理，目的是提高效率。 缓存的原理：如果数据在-128~127区间，那么类加载时就已经为该区间的每一个数值创建好了对象，并将这256个对象存放在名为cache的数组中。每当自动装箱过程发生时(或手动调用valueOf()时)，就会先判断数据是否在该区间，如果在则直接获取数组中对应的包装类对象的引用，如果不在就通过new调用包装类的构造方法来创建对象。 //包装类的缓存区间为[-128,12
浅谈java的基本数据类型、包装类型和缓存池
杨飞的博客
07-30 451
基本类型（四类八种） 整数型：byte，short，int，long 浮点型：float，double 字符型：char 布尔型：boolean 包装类型 每个基本类型都有对应的包装类型，基本类型和其包装类型之间的赋值被称作装箱和拆箱。 Integer x = 1; //这是装箱 int y = x； //这是拆箱 缓存池 问题：new Integer(99) 和 Integer.v...
java封装类和基本数据类型的equals()方法与==比较
weixin_44020096的博客
08-13 1078
1.equals()和== ==的作用是用来判断两个对象的地址是否相等，也就是判断是否为同一个对象(基本数据类型==比较的是值， 引用数据类型==比较的是内存地址) equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况： 情况1：类没有覆盖equals()方法。则通过equals()比较该类的两个对象时，等价于通过“==”比较这两个 对象。自定义对象往往...
基本数据类型包装类.pdf
09-06
基本数据类型包装类是 Java 语言中的一种机制，用于将基本数据类型封装成对象。这些对象可以被存储在集合中、作为方法的参数、返回值等。在 Java 中，基本数据类型包装类包括 Byte、Short、Integer、Long、Character...
28.java基本类型封装.docx
09-20
本文详细介绍了Java中基本数据类型封装的相关知识，包括基本概念、包装类的概述、自动装箱与拆箱以及包装类常量池的具体实现。通过了解这些内容，开发者可以更好地理解和运用Java语言中的基本数据类型及其封装类，...
基本类型包装型的缓存值cache
iCoding91
04-15 1268
1.基本类型包装类型的缓存值 基本类型不包括：float,double bool缓存值：true，false char缓存值：0～127，故ASSII码里面的字符都有缓存 其它范围：－128～127 特殊的int：上限默认为127，但可通过-XX:AutoBoxCacheMax设置。 实现方式：定义了缓存数组(bool定义的是常量)，且为静态代码块，在类加载时即生成。 2...
java integer 缓存_Java基本数据类型和Integer缓存机制
weixin_30158793的博客
02-24 394
一、8种基本数据类型(4整,2浮,1符,1布)​ 整型：byte(最小的数据类型)、short(短整型)、int(整型)、long(长整型)；​ 浮点型：float(浮点型)、double(双精度浮点型)；​ 字符型：char(字符型)；​ 布尔型：boolean(布尔型)。二、取值范围数据类型名称占用字节默认值最小值最大值对应包装类整数类型byte10-128(-2^7)~ 127(2^7-1)...
Java包装类数据缓存
qq_46384325的博客
07-04 90
缓存 装箱：基本数据类型转为包装类； 拆箱：包装类类型转为基本数据类型。 Java中只是对部分基本数据类型对应包装类的部分数据进行了缓存： 1.对Byte，Short，Integer，Long这四种数据类型提前进行缓存，范围为：-128~127（包括首尾）。 Integer a =127; Integer b =127; System. out.println (a==b) ;//true Integer a =128; Integer b =128; System. out.println (a==b)
Java cache类型_Java数据类型之Cache模式
weixin_34652580的博客
02-19 225
1、关于Java数据类型基本数据类型基本数据类型有8种，每种基本数据类型都有对应的引用类型。类型描述长度可表示数据包装类型boolean布尔型1true、falseBooleanbyte字节型12-7~27-1Bytechar字符型22-15~215-1Charactershort短整型22-15~215-1Shortint整型42-31~231-1Integerfloat浮点型42-31~231...
Java的基本变量对象的缓存
SeanMiao
08-16 1374
先看一段代码： public class Main{ public static void main(String[] args) { Integer a=24; Integer b=new Integer(24); System.out.println(a==b); Integer c=23; I...
Java基本类型的包装器类型的缓存策略及双等号使用问题
回归心灵的专栏
11-28 377
背景公司的系统被用户反应有问题，经过排查发现问题出现在两个Integer类型的变量值判断是否相等使用了双等号（==）。由于之前在双等号的使用上吃过苦头，因此看到双等号时就立刻明白问题出在哪里（应该使用equals方法）。但是转念一想，该系统已经用了很长时间了，之前都没有问题，为什么现在出现问题了？经过阅读源码及Java语言规范（jls）找到了出现该现象的原因，所以写此篇文章记录说明。情景再现我们来看
Java8种基本数据类型的封装，Cache
long636的专栏
11-27 1125
今天笔试中java题： （1） public static void main (String []args) { Integer a  = new Integer(1); Integer b  = new Integer(1); int c  = 1; Integer e = 1; System.out.println("a==b:"+(a==b)); System.out.p
由基本数据类型对象缓存引出享元模式
u013634928的博客
09-19 618
l 基本数据类型的对象缓存： Integer num1 = 12; Integer num2 = 12; 这块相等， System.out.println(num1 == num2); Integer num3 = 129;                这块不相等，因为是对象 Integer num4 = 129; System.out.println(num3 == num
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值