吊打面试官系列：说说Integer缓存范围

矫情吗；* 2022-12-24 05:53 134阅读 0赞

关注“Java后端技术全栈”

回复“000”获取大量电子书

本文主要大致思路为：

![format_png][]

不管从工作中还是面试，这篇文章都应该好好看完，本人认为是非常有用的。

#### 案例![format_png 1][] ####

Integer是基本类型int的封装类。平时不管是入坑多年的小伙伴还在入坑路上的小伙伴，都应该知道的使用频率是相当高。

下面模仿订单支付，做了一个订单支付状态枚举类`PayStatusEnum`

public class IntegerDemo {
        public static void main(String[] args) {
            Integer a = new Integer(8);
            Integer b = Integer.valueOf(8);
            Integer c = 8;
            System.out.println(a.equals(b));
            System.out.println(a.equals(c));
            System.out.println(b.equals(c));
    
            System.out.println(a == b);
            System.out.println(a == c);
            System.out.println(b == c);
        }
    }

结果输出什么？

把上面代码中的8改成128后，又输出什么？

public class IntegerDemo {
        public static void main(String[] args) {
            Integer a = new Integer(128);
            Integer b = Integer.valueOf(128);
            Integer c = 128;
            System.out.println(a.equals(b));
            System.out.println(a.equals(c));
            System.out.println(b.equals(c));
    
            System.out.println(a == b);
            System.out.println(a == c);
            System.out.println(b == c);
        }
    }

答案慢慢道来。

#### 解析案例![format_png 1][] ####

##### Integer整体阅览 #####

![format_png 2][]

##### 构造方法 #####

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

太简单了，没什么可讲的。

##### valueOf()方法 #####

public static Integer valueOf(String s) throws NumberFormatException {
       return Integer.valueOf(parseInt(s, 10));
    }
    //@HotSpotIntrinsicCandidate 这个注解是JDK9才引入的
    //HotSpot 虚拟机将对标注了@HotSpotIntrinsicCandidate注解的方法的调用，
    //替换为直接使用基于特定 CPU 指令的高效实现。这些方法我们便称之为 intrinsic。
    public static Integer valueOf(int i) {
       //如果i在low和high之间就使用缓存
       if (i >= IntegerCache.low && i <= IntegerCache.high){
            return IntegerCache.cache[i + (-IntegerCache.low)];
       }
       return new Integer(i);
    }

上面`valueOf()`方法中用到了`IntegerCache`，下面我们来聊聊。

##### IntegerCache #####

下面是`IntegerCache`源码和部分注释：

/**
         * Cache to support the object identity semantics of autoboxing for values between
         * -128 and 127 (inclusive) as required by JLS.
         * JLS协议要求缓存在-128到127之间（包含边界值）
         *
         * The cache is initialized on first usage.  
         * 程序第一次使用Integer的时候
         * The size of the cache may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
         * JVM 的启动参数 -XX:AutoBoxCacheMax=size 修改最大值
         * During VM initialization, java.lang.Integer.IntegerCache.high property
         * may be set and saved in the private system properties in the
         * sun.misc.VM class.
         * 可以通过系统属性来获得：-Djava.lang.Integer.IntegerCache.high=<size>
         */   
    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");
                //如果有配置-XX:AutoBoxCacheMax=<size>
                if (integerCacheHighPropValue != null) {
                    try {
                        int i = parseInt(integerCacheHighPropValue);
                        //和127进行比较，谁大用谁
                        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.
                        // 如果该值配置错误则忽略该参数配置的值，使用默认范围-128~127
                    }
                }
                high = h;
    
                cache = new Integer[(high - low) + 1];
                int j = low;
                // 缓存通过for循环来实现，创建范围内的整数对象并存储到cache数组中
                // 程序第一次使用Integer的时候需要一定的额外时间来初始化该缓存
                for(int k = 0; k < cache.length; k++){
                    cache[k] = new Integer(j++);
                }
                //无论如何，缓存的最大值肯定是大于等于127
                assert IntegerCache.high >= 127;
            }
            //私有的构造方法，因为所有的属性均属于类常量
            private IntegerCache() {}
    }

整个静态块：

![format_png 3][]

那么，如何设置`java.lang.Integer.IntegerCache.high`的值呢？

`The size of the cache may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.`

注释中已经说清楚，可以使用`-XX:AutoBoxCacheMax=<size>`设置。

写个demo来debug看看

public class IntegerDemo {
        public static void main(String[] args) {
            Integer a = 8;
            Integer b =Integer.valueOf(8);
            System.out.println(a.equals(b));
            System.out.println(a == b);
        }
    }

###### 设置\`-XX:AutoBoxCacheMax\`=100 ######

![format_png 4][]

开始debug

![format_png 5][]

看看high的值

![format_png 6][]

是127，那就对了，因为上面

![format_png 7][]

###### 设置\`-XX:AutoBoxCacheMax\`=130 ######

![format_png 8][]

开启debug模式

![format_png 9][]

> 注意：low=-128是不会变的，整个缓存初始化过程并没有对low进行修改，再说low是常量。

###### \-XX:AutoBoxCacheMax最大能设置成多大？ ######

因为Integer的最大值是2147483647 ，所以我们这里使用这个值试试，

![format_png 10][]

开始debug，直接报`OOM`了

![format_png 11][]

为什么会`OOM`呢？

![format_png 12][]

如果`-XX:AutoBoxCacheMax`没有设置值，那么对应数组是这样的。

![format_png 13][]

##### equals()方法 #####

上面的案例中有equals方法，这里把这个方法也拿出来聊聊

private final int value;
    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            //这里比较的是两个int类型的值
            return value == ((Integer)obj).intValue();
        }  
        //obj不是Integer类型直接返回false
        return false;
    }

##### 回到上面的案例中 #####

当我们使用equals方法比较两个对象是否相等的时候其实就是比较他们的value值。

**所以不管是128还是8，equals后肯定都是true。**

当引用类型使用==进行比较的时候，此时比较的是两个引用的对象的地址，是不是同一个。

我们看看器class文件中的字节码；

本地变量表

![format_png 14][]

每个本地变量赋值的过程

![format_png 15][]

这里我们可以得出一个结论：

`Integer c =8;`就是`Integer c = Integer.valueOf(8);`

上面`Integer b = Integer.valueOf(8);`，那就说明变量b和c都是使用`Integer.valueOf()`获取到的。

`valueOf`方法中

![format_png 16][]

###### \-XX:AutoBoxCacheMax不设置 ######

上面关于IntegerCache的low和high已经进行了说明,low永远是-128，所以当我们没有设置

`-XX:AutoBoxCacheMax`  的值的时候，这时候 high=127。

当`Integer.valueOf(8);`的时候，就会进入上面代码中的if中。然后从`IntegerCache`中的数组cache中获取。

但是`IntegerCache`中的cache数组是个常量数组。

![format_png 17][]

言外之意，就是一旦给这个数组cache赋值后，就不会变了。

`Integer b = Integer.valueOf(8);`和`Integer c=8;`

b和c不就是都指向同一个引用地址吗？

所以 b==c为true;

![format_png 18][]

但是`Integer b=Integer.valueOf(128);`

此时就不进入if中，而是直接new一个Integer对象

![format_png 19][]

所以此时

`Integer b=Innteger.valueOf(128) ；`和`Integer c = 128;`

都会各自new 一个Integer对象，

此时的b==c为false。

![format_png 20][]

这里也就是网上很多文章也就说到这里，就是比较当前int i 这个i是不是在-128到127范围之内。

###### \-XX:AutoBoxCacheMax设置为130 ######

如果我们把`-XX:AutoBoxCacheMax`设置为130。那么上面

`Integer b=Innteger.valueOf(128) ；`和`Integer c = 128;`

也会进入if条件中。

最后b==c为true。

![format_png 21][]

#### 如何避坑![format_png 1][] ####

Integer是基本类型int的封装类，那么在平常使用的时候需要注意几点：

1，如果使用Integer，注意Integer的默认是null，容易引起空指针异常`NullPointerException`。

2，如果使用int类型，注意int类型的初始值是0，很多设计某某状态时，很喜欢用0作为某个状态，这里要小心使用。

3，另外从内存使用层面来讲，int是基本数据类型，只占用4个字节，Integer是一个对象，当表示一个值时Integer占用的内存空间要高于int类型，从节省内存空间考虑，建议使用int类型（建议了解一下Java对象内存布局）。

4，Integer使用的时候，直接赋值，Integer c = 8，不要new Integer(8)。因为直接赋值就是`Integer.valueOf`方法使用缓存，没必要每次都new一个新对象，有效提高内存使用。

5，如果系统中大量重复的使用比127大的数，建议`JVM`启动的时候为-`XX:AutoBoxCacheMax=size` 适当的大小，提升内存使用效率（但是也不能太大，上面我们已经演示了可能出现`OOM`）。

#### 面试题![format_png 1][] ####

##### 面试题1 #####

Integer num1 = new Integer(10);
    Integer num2 = new Integer(10);
    
    System.out.println(num1.equals(num2)); 
    System.out.println(num1 == num2);

##### 面试题2 #####

Integer num3 = 100;
    Integer num4 = 100;
    System.out.println(num3.equals(num4)); 
    System.out.println(num3 == num4);

##### 面试题3 #####

Integer num5 = 1000;
    Integer num6 = 1000;
    System.out.println(num5.equals(num6)); 
    System.out.println(num5 == num6);

把上面看完了，再回头来看看这种面试题，还难吗？

如果在面试中遇到面试题3，可以适当反问一下面试官是否有对缓存范围进行调整，或许某些面试官都会懵逼。

赤裸裸的吊打面试官。

#### 总结![format_png 1][] ####

1.引用类型的==是比较对应的引用地址。

2.Integer中使用的默认缓存是-128到127。但是可以在`JVM`启动的时候进行设置。

3.`Integer b=Integer.valueOf(8);`和`Integer b=8;`是一样的效果。

4.`Integer.valueOf()`方式，比较是否在缓存范围之内，在就直接从缓存中获取，不在new一个Integer对象。

5.每次使用new来创建Integer对象，是用不到`IntegerCache`缓存的。

6.Integer中的使用缓存的方式也可以理解为**享元模式**。

推荐阅读：

[《Spring Cloud与Docker微服务架构实战》.pdf][Spring Cloud_Docker_.pdf]

[《Go语言实战》.pdf][Go_.pdf]

[《分布式Java应用基础与实践》.pdf][Java_.pdf]

![format_png 22][]

[format_png]: /images/20221120/0dfdb4fd6589481e9c14712852b2fc2f.png
[format_png 1]: /images/20221120/74c4187fe56a4531892e48227668a7d0.png
[format_png 2]: /images/20221120/ab88c95c34f14f0bb3a666b7d64c6bda.png
[format_png 3]: /images/20221120/913200eb76c749f28620468afe850936.png
[format_png 4]: /images/20221120/75385cd672464b04af9b1becaec33334.png
[format_png 5]: /images/20221120/bb2a8b7621ad4bb996c481b3c385cab2.png
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiRVVsaWE5R3NKU3A2R1Bja3hlT1QyZWZraGEyaWJLUWlibm1pYkU0RDRPaWNFRGpmSHYwTmc1YnBQRkEvNjQw?x-oss-process=image/format,png
[format_png 7]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiN21WQ2pXTmpFOFZvZWtzdG1FN1J3UExpYUZGcW5HWFlsd01XVkJlbnRhZ1U3c2pHMnVNNjhyQS82NDA?x-oss-process=image/format,png
[format_png 8]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiQ003Z1JXcGppYkJ2TWZEZTZWc2Q5aWJaQzNGSmdXeWljUkVBNzM0dDNNTXkyU216UDdJT2liT3NYdy82NDA?x-oss-process=image/format,png
[format_png 9]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiS1NpY29OU0xZaWFBZWJ2V3hhU1hlaHNzakhMdUdSMzFLY1JGeVZpYjQ5WUIyYmliSE5Za05BQ3lQZy82NDA?x-oss-process=image/format,png
[format_png 10]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiaWFpYmNNcXBQSlgwZk41WVNGN0NlVklCRUwwM3c4MWhEOVhSMUxZMHJBOWVkNXFnOXFZZ2FHTkEvNjQw?x-oss-process=image/format,png
[format_png 11]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiZDlGUzV3UHVMcWljRnBpYWxYNmliaHd2Y0QxWTdzd1ZjWTEwNHIyRGRPYXg4WDJzMGd1WWVrb3RBLzY0MA?x-oss-process=image/format,png
[format_png 12]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiV0R3cXhIcURlaWNCNnE1clZCQXQxdk4yMDRickpYRHg0S0w3NU9OdTlpYVVkRkQyZGZPWFV1TEEvNjQw?x-oss-process=image/format,png
[format_png 13]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiODAwSW1oVWg4VDZXdTFtNWpnTFVTNTZ4UWliV295cXA1eDhnQ2JubGh6dVY3TTlNQ09pYTBpYUxnLzY0MA?x-oss-process=image/format,png
[format_png 14]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiakw3MDBsc0V4Z0JpYWNhOVBEY0xHMVBqY09uWVNpYmJCYU5CMlZNSkRGZU00dUFNME1tZnY2dEEvNjQw?x-oss-process=image/format,png
[format_png 15]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiclBiU0YwcXlva0tkUU9wN2lhYU9XUFNYV29DNmJDZ1lpYm00VUFjMlpSUVQzM3hRRXpONUUxQVEvNjQw?x-oss-process=image/format,png
[format_png 16]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiZ3R5bXNsdTVpY0tFcFNMWWpoRDdKV2ZNczhmTDF2dGxMWjdYaWJpYU1ISE9mR3FxOXBveE1ndllnLzY0MA?x-oss-process=image/format,png
[format_png 17]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiaWJQcldNc01KTHFDYzdoUXdBTkRCMmZrTlJHSHRMUmR0aWFKa1pxRzN4dk5pY1lqNEJRZlVsNEVRLzY0MA?x-oss-process=image/format,png
[format_png 18]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiaWJSWUEzMXZ2TkdoNEd1WHdLR0draWN2Z3JJV1kxbkpIdmljVWVJR3U2ejZnVE9TRFFuSUtzUm53LzY0MA?x-oss-process=image/format,png
[format_png 19]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiV1lZSUo5V2NrbmlhVVVMWVRoanNRTk84YkhsblZuWFFXRjRYQ1pIM2E5b3lRUmt1WDdlU00zQS82NDA?x-oss-process=image/format,png
[format_png 20]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiN2h1N3p3N0x3M2RKdjlVYndhVU9tSEtOWGljaWN2V2xNMG1XamhPWG1EUFFjRDRrOFdjWWxHcGcvNjQw?x-oss-process=image/format,png
[format_png 21]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGt2RWNkOElVMlR3TjlCVk1Na0ppYXJiQVdJeWtwZ21ORVJjUVVWSGpUYXU5eGczMjNpYmljWmsycEFUM1NkaWNGcnNWTnhzMkMxNUs1TXZBLzY0MA?x-oss-process=image/format,png
[Spring Cloud_Docker_.pdf]: http://mp.weixin.qq.com/s?__biz=MzU4MDM3MDgyMA%3D%3D&chksm=fd554f4fca22c659e3bece445e96665220157ed1baa6072085c9cf042f6babf3296486e65312&idx=2&mid=2247493540&scene=21&sn=92819bea83b62a1ac22dfcd32a7eaaca#wechat_redirect
[Go_.pdf]: http://mp.weixin.qq.com/s?__biz=MzU4MDM3MDgyMA%3D%3D&chksm=fd554cd1ca22c5c76d859e461bf04af7c4afdc8e7edc6685532fa08fb19102e661504cfdc2b2&idx=2&mid=2247492666&scene=21&sn=6a41d45ce0db444401c228c58d54da48#wechat_redirect
[Java_.pdf]: http://mp.weixin.qq.com/s?__biz=MzU4MDM3MDgyMA%3D%3D&chksm=fd554f24ca22c632b04239af1f5773e80ebc57e3edf862b36b05c04d3a6c46152b6d59150ad3&idx=2&mid=2247493583&scene=21&sn=92a1a85e936723e92f21740e087e3784#wechat_redirect
[format_png 22]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8wN0JpY1p5d09WdGtrNW5LTTFoT2FSMGlhWHhHSDdpYnVrUEpPUmpvcFRYOGxKNUVscHZyWFBtRzZKNUZlOGVlWUJvclNpYlJKeW00aWN5T1d1cHB5dHgxYzlBLzY0MA?x-oss-process=image/format,png