爲何阿里巴巴Java開發手冊中強制要求整型包裝類對象值用 equals 方法比較？

時間  2019-11-18
標籤 爲何 阿里巴巴 java 開發 手冊 強制 要求 整型 包裝 對象 equals 方法 比較 欄目 阿里巴巴 简体版
原文   原文鏈接

在閱讀《阿里巴巴Java開發手冊》時，發現有一條關於整型包裝類對象之間值比較的規約，具體內容以下：html

這條建議很是值得你們關注， 並且該問題在 Java 面試中十分常見。java

還須要思考如下幾個問題：面試

  1. 若是不看《阿里巴巴Java開發手冊》，如何知道 Integer var = ? 會緩存 -128 到 127 之間的賦值？數組

  2. 爲何會緩存這個範圍的賦值？緩存

  3. 如何學習和分析相似的問題？ide

Integer 緩存問題分析

先看下面的示例代碼，並思考該段代碼的輸出結果：函數

public class IntegerTest {	public static void main(String[] args) {
	    Integer a = 100, b = 100, c = 666, d = 666;
	    System.out.println(a == b);
	    System.out.println(c == d);
	}
}

經過運行代碼能夠獲得答案，程序輸出的結果分別爲： true , false。工具

那麼爲何答案是這樣？源碼分析

結合《阿里巴巴Java開發手冊》的描述不少人可能會回答：由於緩存了 -128 到 127 之間的數值，就沒有而後了。性能

那麼爲何會緩存這一段區間的數值？緩存的區間能夠修改嗎？其它的包裝類型有沒有相似緩存？

接下來，讓咱們一塊兒進行分析。

源碼分析法

首先咱們能夠經過源碼對該問題進行分析。

咱們知道，Integer var = ? 形式聲明變量，會經過 java.lang.Integer#valueOf(int) 來構造 Integer 對象。

怎麼知道會調用 valueOf() 方法呢？

你們能夠經過打斷點，運行程序後會調到這裏。

先看 java.lang.Integer#valueOf(int) 源碼：

/**
 * Returns an {@code Integer} instance representing the specified
 * {@code int} value.  If a new {@code Integer} instance is not
 * required, this method should generally be used in preference to
 * the constructor {@link #Integer(int)}, as this method is likely
 * to yield significantly better space and time performance by
 * caching frequently requested values.
 *
 * This method will always cache values in the range -128 to 127,
 * inclusive, and may cache other values outside of this range.
 *
 * @param  i an {@code int} value.
 * @return an {@code Integer} instance representing {@code i}.
 * @since  1.5
 */public static Integer valueOf(int i) {    if (i >= IntegerCache.low && i <= IntegerCache.high)        return IntegerCache.cache[i + (-IntegerCache.low)];    return new Integer(i);
}

經過源碼能夠看出，若是用 Ineger.valueOf(int) 來建立整數對象，參數大於等於整數緩存的最小值（ IntegerCache.low ）並小於等於整數緩存的最大值（ IntegerCache.high）, 會直接從緩存數組 (java.lang.Integer.IntegerCache#cache) 中提取整數對象；不然會 new 一個整數對象。在 JDK9 直接把 new 的構造方法標記爲 deprecated，推薦使用 valueOf()，合理利用緩存，提高程序性能。

那麼這裏的緩存最大和最小值分別是多少呢？

從上述註釋中咱們能夠看出，最小值是 -128, 最大值是 127。

那麼爲何會緩存這一段區間的整數對象呢？

經過註釋咱們能夠得知：若是不要求必須新建一個整型對象，緩存最經常使用的值（提早構造緩存範圍內的整型對象），會更省空間，速度也更快。

這給咱們一個很是重要的啓發：

若是想減小內存佔用，提升程序運行的效率，能夠將經常使用的對象提早緩存起來，須要時直接從緩存中提取。

那麼咱們再思考下一個問題： Integer 緩存的區間能夠修改嗎？

經過上述源碼和註釋咱們還沒法回答這個問題，接下來，咱們繼續看 java.lang.Integer.IntegerCache 的源碼：

/**
 * Cache to support the object identity semantics of autoboxing for values between
 * -128 and 127 (inclusive) as required by JLS.
 *
 * The cache is initialized on first usage.  The size of the cache
 * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 * 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.
 */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");           // 省略其它代碼
    }      // 省略其它代碼}

經過 IntegerCache 代碼和註釋咱們能夠看到，最小值是固定值 -128， 最大值並非固定值，緩存的最大值是能夠經過虛擬機參數 -XX:AutoBoxCacheMax=<size>} 或 -Djava.lang.Integer.IntegerCache.high=<value> 來設置的，未指定則爲 127。

所以能夠經過修改這兩個參數其中之一，讓緩存的最大值大於等於 666。

若是做出這種修改，示例的輸出結果便會是： true,true。

學到這裏是否是發現，對此問題的理解和最初的想法有些不一樣呢？

這段註釋也解答了爲何要緩存這個範圍的數據：

是爲了自動裝箱時能夠複用這些對象 ，這也是 JLS2 的要求。

咱們能夠參考 JLS 的 Boxing Conversion 部分的相關描述。

If the valuepbeing boxed is an integer literal of type intbetween -128and 127inclusive (§3.10.1), or the boolean literal trueorfalse(§3.10.3), or a character literal between '\u0000'and '\u007f'inclusive (§3.10.4), then let aand bbe the results of any two boxing conversions of p. It is always the case that a==b.

在 -128 到 127 （含）之間的 int 類型的值，或者 boolean 類型的 true 或 false， 以及範圍在’\u0000’和’\u007f’ （含）之間的 char 類型的數值 p， 自動包裝成 a 和 b 兩個對象時， 可使用 a == b 判斷 a 和 b 的值是否相等。

反編譯法

那麼究竟 Integer var = ? 形式聲明變量，是否是經過 java.lang.Integer#valueOf(int) 來構造 Integer 對象呢？ 總不能都是猜想 N 個可能的函數，而後斷點調試吧？

若是遇到其它相似的問題，沒人告訴我底層調用了哪一個方法，該怎麼辦？

這類問題，能夠經過對編譯後的 class 文件進行反編譯來查看。

首先編譯源代碼：javac IntegerTest.java

而後須要對代碼進行反編譯，執行：javap -c IntegerTest

若是想了解 javap 的用法，直接輸入 javap -help 查看用法提示（不少命令行工具都支持 -help 或 --help 給出用法提示）。

反編譯後，咱們獲得如下代碼：

Compiled from "IntegerTest.java"public class com.wupx.demo.IntegerTest {
  public com.wupx.demo.IntegerTest();
    Code:       0: aload_0       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:       0: bipush        100
       2: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       5: astore_1       6: bipush        100
       8: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      11: astore_2      12: sipush        666
      15: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      18: astore_3      19: sipush        666
      22: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      25: astore        4
      27: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      30: aload_1      31: aload_2      32: if_acmpne     39
      35: iconst_1      36: goto          40
      39: iconst_0      40: invokevirtual #4                  // Method java/io/PrintStream.println:(Z)V
      43: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      46: aload_3      47: aload         4
      49: if_acmpne     56
      52: iconst_1      53: goto          57
      56: iconst_0      57: invokevirtual #4                  // Method java/io/PrintStream.println:(Z)V
      60: return}

能夠明確得看到這四個 Integer var = ? 形式聲明的變量的確是經過 java.lang.Integer#valueOf(int) 來構造 Integer 對象的。

接下來對編譯後的代碼進行詳細分析，若是看不懂可略過：

根據《Java Virtual Machine Specification : Java SE 8 Edition》3，後縮寫爲 JVMS , 第 6 章 虛擬機指令集的相關描述以及《深刻理解 Java 虛擬機》4 414-149 頁的 附錄 B 「虛擬機字節碼指令表」。 咱們對上述指令進行解讀：

偏移爲 0 的指令爲：bipush 100 ，其含義是將單字節整型常量 100 推入操做數棧的棧頂；

偏移爲 2 的指令爲：invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer; 表示調用一個 static 函數，即 java.lang.Integer#valueOf(int)；

偏移爲 5 的指令爲：astore_1 ，其含義是從操做數棧中彈出對象引用，而後將其存到第 1 個局部變量 Slot 中；

偏移 6 到 25 的指令和上面相似；

偏移爲 30 的指令爲 aload_1 ，其含義是從第 1 個局部變量 Slot 取出對象引用（即 a），並將其壓入棧；

偏移爲 31 的指令爲 aload_2 ，其含義是從第 2 個局部變量 Slot 取出對象引用（即 b），並將其壓入棧；

偏移爲 32 的指令爲 if_acmpn，該指令爲條件跳轉指令，if_ 後以 a 開頭表示對象的引用比較。

因爲該指令有如下特性：

if_acmpeq 比較棧兩個引用類型數值，相等則跳轉 if_acmpne 比較棧兩個引用類型數值，不相等則跳轉 因爲 Integer 的緩存問題，因此 a 和 b 引用指向同一個地址，所以此條件不成立（成立則跳轉到偏移爲 39 的指令處），執行偏移爲 35 的指令。

偏移爲 35 的指令: iconst_1，其含義爲將常量 1 壓棧（ Java 虛擬機中 boolean 類型的運算類型爲 int ，其中 true 用 1 表示，詳見 2.11.1 數據類型和 Java 虛擬機。

而後執行偏移爲 36 的 goto 指令，跳轉到偏移爲 40 的指令。

偏移爲 40 的指令：invokevirtual #4 // Method java/io/PrintStream.println:(Z)V。

可知參數描述符爲 Z ，返回值描述符爲 V。

根據 4.3.2 字段描述符 ，可知 FieldType 的字符爲 Z 表示 boolean 類型， 值爲 true 或 false。 根據 4.3.3 字段描述符 ，可知返回值爲 void。

所以能夠知，最終調用了 java.io.PrintStream#println(boolean) 函數打印棧頂常量即 true。

而後比較執行偏移 43 到 57 之間的指令，比較 c 和 d， 打印 false 。

執行偏移爲 60 的指令，即 return ，程序結束。

可能有些朋友會對反編譯的代碼有些抵觸和恐懼，這都是很是正常的現象。

咱們分析和研究問題的時候，看懂核心邏輯便可，不要糾結於細節，而失去了重點。

一回生兩回熟，隨着遇到的例子愈來愈多，遇到相似的問題時，會喜歡上 javap 來分析和解決問題。

若是想深刻學習 java 反編譯，強烈建議結合官方的 JVMS 或其中文版:《Java 虛擬機規範》這本書進行拓展學習。

Long 的緩存問題分析

學習的目的之一就是要學會觸類旁通，所以對 Long 也進行相似的研究，探究二者之間有何異同。

源碼分析

相似的，接下來分析 java.lang.Long#valueOf(long) 的源碼：

/**
 * Returns a {@code Long} instance representing the specified
 * {@code long} value.
 * If a new {@code Long} instance is not required, this method
 * should generally be used in preference to the constructor
 * {@link #Long(long)}, as this method is likely to yield
 * significantly better space and time performance by caching
 * frequently requested values.
 *
 * Note that unlike the {@linkplain Integer#valueOf(int)
 * corresponding method} in the {@code Integer} class, this method
 * is <em>not</em> required to cache values within a particular
 * range.
 *
 * @param  l a long value.
 * @return a {@code Long} instance representing {@code l}.
 * @since  1.5
 */public static Long valueOf(long l) {    final int offset = 128;    if (l >= -128 && l <= 127) { // will cache
        return LongCache.cache[(int)l + offset];
    }    return new Long(l);
}

發現該函數的寫法和 Ineger.valueOf(int) 很是類似。

咱們一樣也看到， Long 也用到了緩存。 使用 Ineger.valueOf(int) 構造 Long 對象時，值在 [-128, 127] 之間的 Long 對象直接從緩存對象數組中提取。

並且註釋一樣也提到了：緩存的目的是爲了提升性能。

可是經過註釋咱們發現這麼一段提示：

Note that unlike the {@linkplain Integer#valueOf(int) corresponding method} in the {@code Integer} class, this method is not required to cache values within a particular range.

注意：和 Ineger.valueOf(int) 不一樣的是，此方法並無被要求緩存特定範圍的值。

這也正是上面源碼中緩存範圍判斷的註釋爲什麼用 // will cache 的緣由（能夠對比一下上面 Integer 的緩存的註釋）。

所以咱們可知，雖然此處採用了緩存，但應該不是 JLS 的要求。

那麼 Long 類型的緩存是如何構造的呢？

咱們查看緩存數組的構造：

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);
    }
}

能夠看到，它是在靜態代碼塊中填充緩存數組的。焦做國醫胃腸醫院口碑怎麼樣：http://jz.lieju.com/zhuankeyiyuan/37324643.htm

反編譯

一樣地咱們也編寫一個示例片斷：

public class LongTest {    public static void main(String[] args) {
        Long a = -128L, b = -128L, c = 666L, d = 666L;
        System.out.println(a == b);
        System.out.println(c == d);
    }
}

編譯源代碼： javac LongTest.java

對編譯後的類文件進行反編譯: javap -c LongTesg

獲得下面反編譯的代碼：

Compiled from "LongTest.java"public class com.wupx.demo.LongTest {
  public com.wupx.demo.LongTest();
    Code:       0: aload_0       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:       0: ldc2_w        #2                  // long -128l
       3: invokestatic  #4                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
       6: astore_1       7: ldc2_w        #2                  // long -128l
      10: invokestatic  #4                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
      13: astore_2      14: ldc2_w        #5                  // long 666l
      17: invokestatic  #4                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
      20: astore_3      21: ldc2_w        #5                  // long 666l
      24: invokestatic  #4                  // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
      27: astore        4
      29: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
      32: aload_1      33: aload_2      34: if_acmpne     41
      37: iconst_1      38: goto          42
      41: iconst_0      42: invokevirtual #8                  // Method java/io/PrintStream.println:(Z)V
      45: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
      48: aload_3      49: aload         4
      51: if_acmpne     58
      54: iconst_1      55: goto          59
      58: iconst_0      59: invokevirtual #8                  // Method java/io/PrintStream.println:(Z)V
      62: return}

從上述代碼中發現 Long var = ? 的確是經過 java.lang.Long#valueOf(long) 來構造對象的。

事實上，除 Float 和 Double 外，其餘包裝數據類型都會緩存，6 個包裝類直接賦值時，就是調用對應包裝類的靜態工廠方法 valueOf()。http://m.qd8.com.cn/yiyao/xinxi21_3709995.html

各個包裝類的緩存區間以下：

  • Boolean：使用靜態 final 變量定義，valueOf() 就是返回這兩個靜態值

  • Byte：表示範圍是 -128 ~ 127，所有緩存

  • Short：表示範圍是 - 32768 ~ 32767，緩存範圍是 -128~127

  • Character：表示範圍是 0 ~ 65535，緩存範圍是 0~127

  • Long：表示範圍是 [-2^63 ~ 2^63-1]，緩存範圍是 -128~127

  • Integer：表示範圍是 [-2^31 ~ 2^31-1]，緩存範圍是 -128~127，但它是惟一能夠修改緩存範圍的包裝類，在 VM options 加入參數 -XX:AutoBoxCacheMax=6666，便可設置最大緩存值爲 6666

另外，在選擇使用包裝類仍是基本數據類型時，推薦使用以下方式：

  1. 全部的 POJO 類屬性必須使用包裝數據類型

  2. RPC 方法的返回值和參數必須使用包裝數據類型

  3. 全部的局部變量推薦使用基本數據類型

總結

本文首先對阿里巴巴Java開發手冊中強制要求整型包裝類對象值用 equals 方法比較做了簡單介紹，並經過源碼分析法、閱讀 JLS 和 JVMS、使用反編譯法，對 Integer 和 Long 緩存的目的和實現方式問題進行了深刻分析。

讓你們可以用更豐富的手段來學習知識和分析問題，經過對緩存目的的思考來學到更通用和本質的東西。

還介紹了其餘包裝類型的緩存範圍，以及包裝類和基本數據類型的推薦使用場景。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程