Integer是有小資料快取的機制的，那麼第一個是否應該是true呢？

迴歸下第一個：

1. Integer num1 = new Integer(100);

2. Integer num2 = new Integer(100);

3. System.out.println(num1 == num2);

言歸正傳，

上篇提到說，這個的執行結果是false，原因在上篇文章中有解釋，但是，對於Integer的小資料快取是怎麼一回事？難道這兩個是矛盾的嗎？

PS：灰常感謝朋友的提出Integer快取問題（之前不知道有這個機制）瞬間漲知識了。

那麼Integer快取是怎麼回事呢？

還是用程式碼的方式來解決問題吧，下面是程式碼，同樣，你覺得輸出結果會是什麼？

1. public static void main(String[] args) {

2.     Integer num1 = new Integer(100);

3.     Integer num2 = new Integer(100);

4.     System.out.println("num1==num2 " + (num1 == num2));

5.      

6.     Integer num3 = 100;

7.     Integer num4 = 100;

8.     System.out.println("num3==num4 " +(num3 == num4));

9.      

10.     Integer num5 = 128;

11.     Integer num6 = 128;

12.     System.out.println("num5==num6 " + (num5 == num6));

13.      

14.     Integer num7 = 100;

15.     Integer num8 = new Integer(100);

16.     System.out.println("num7==num8 " + (num7 == num8));

17.      

18.     int num9 = 100;

19.     Integer num10 = new Integer(100);

20.     Integer num11 = 100;

21.     System.out.println("num9==num10 " + (num9 == num10));

22.     System.out.println("num9==num11 " + (num9 == num11));

23.  

24. }

執行之後的輸出結果是：

num1==num2 false

這個上次的文章中已經解釋過了，num1和num2的記憶體地址不一樣，==的左右運算元如果是物件的話，那麼比較的是引用的地址，new產生的物件一定是新的記憶體地址，所以，這裡和Integer的快取機制無關的，最終的結果便是false

num3==num4 true

這裡是true，num3和num4的初始化方式，是直接將數字賦值，這種方式，在初始化的時候，等價與下面的程式碼：

Integer num3 = Integer.valueOf(100);

這裡便涉及到了Integer的快取機制問題， Integer是對小資料（-128~127）是有快取的，再jvm初始化的時候，資料-128~127之間的數字便被快取到了本地記憶體中，這樣，如果初始化-128~127之間的數字，便會直接從記憶體中取出，而不需要再新建一個物件（後面會分析valueOf的程式碼和快取的一點事情），所以，100這個數字再-128~127之間，那麼num3和num4實際上是引用的是一個記憶體地址，那麼自然就是true了。

num5==num6 false

同上解析，128已經不在-128~127之間了，所以會使用new新建個物件，那麼num5和num6的記憶體地址就不一樣了，結果就是false

num7==num8 false

這個和第一個的解釋基本一致，因為num8是new出來的，所以使用的記憶體地址和num7不一致，結果為false

num9==num10 true

這個就比較好玩了，這個和上面的那個唯一的區別在於num9的型別是int而num7的型別是Integer，那麼為啥這裡是true呢？

Integer是int的包裝類，在和int做比較的時候，會自動拆箱成int數值型別，所以，這裡便變成了數字（int）的比較，so。。100肯定等於100啦~

num9==num11 true

解析同上（不需要關注到底是否是new出來，因為最終都要拆箱，最終都要將比較變成基本資料型別的比較）

附：關於Integer的快取的原始碼分析。

首先是valueOf的程式碼分析：

1. public static Integer valueOf(int i) {

2. assert IntegerCache.high >= 127;

3. if (i >= IntegerCache.low && i <= IntegerCache.high)

4.     return IntegerCache.cache[i + (-IntegerCache.low)];

5. return new Integer(i);

6. }

可以看到，在執行valueOf的時候，會先去檢查記憶體中是否存在該數字，如果存在的話，就直接從記憶體中取出返回，如果不存在的話，就新建一個Integer物件。

這裡涉及到了一個IntegerCache.high的數值~~，讓我們看下它是怎麼初始化的

1. private static class IntegerCache {

2.     static final int low = -128;

3.     static final int high;

4.     static final Integer cache[];

5.     static {

6.         // high value may be configured by property

7.         int h = 127;

8.         String integerCacheHighPropValue =

9.             sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");

10.         if (integerCacheHighPropValue != null) {

11.             int i = parseInt(integerCacheHighPropValue);

12.             i = Math.max(i, 127);

13.             // Maximum array size is Integer.MAX_VALUE

14.             h = Math.min(i, Integer.MAX_VALUE - (-low));

15.         }

16.         high = h;

17.         cache = new Integer[(high - low) + 1];

18.         int j = low;

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

20.             cache[k] = new Integer(j++);

21.     }

22.     private IntegerCache() {}

23. }

可以看到，hign的值，預設是127， 如果java.lang.Integer.IntegerCache.high的變數有設定，則取這個值。jvm再初始化的時候，會將低值（-128）到高值（預設127）之間的數字載入到記憶體中。

不知道有沒有注意到： 低值是固定的，不能改變，只能是-128，但是高值是可以通過jvm引數改變的~

So，如果業務場景下，需要將高值變更怎麼設定呢？

在java程式執行的時候加上 -XX:AutoBoxCacheMax=<size> 的引數即可~~ 可以嘗試下設定成200，那麼上面的demo栗子的中的結果會變化哦~~

其他包裝型別也是有快取機制的~~不妨看下~~

from: https://blog.csdn.net/YingHuaNanHai/article/details/80735821