为什么阿里巴巴Java开发手册中强制要求整型包装类对象值用 equals 方法比较？
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了为什么阿里巴巴Java开发手册中强制要求整型包装类对象值用 equals 方法比较？，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含14369字，纯文字阅读大概需要21分钟。
内容图文
在阅读《阿里巴巴Java开发手册》时，发现有一条关于整型包装类对象之间值比较的规约，具体内容如下：
这条建议非常值得大家关注， 而且该问题在 Java 面试中十分常见。
还需要思考以下几个问题：
如果不看《阿里巴巴Java开发手册》，如何知道 Integer var = ? 会缓存 -128 到 127 之间的赋值？
为什么会缓存这个范围的赋值？
如何学习和分析类似的问题？
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
另外，在选择使用包装类还是基本数据类型时，推荐使用如下方式：
所有的 POJO 类属性必须使用包装数据类型
RPC 方法的返回值和参数必须使用包装数据类型
所有的局部变量推荐使用基本数据类型
总结
本文首先对阿里巴巴Java开发手册中强制要求整型包装类对象值用 equals 方法比较作了简单介绍，并通过源码分析法、阅读 JLS 和 JVMS、使用反编译法，对 Integer 和 Long 缓存的目的和实现方式问题进行了深入分析。
让大家能够用更丰富的手段来学习知识和分析问题，通过对缓存目的的思考来学到更通用和本质的东西。
还介绍了其他包装类型的缓存范围，以及包装类和基本数据类型的推荐使用场景。
内容总结
以上是互联网集市为您收集整理的为什么阿里巴巴Java开发手册中强制要求整型包装类对象值用 equals 方法比较？全部内容，希望文章能够帮你解决为什么阿里巴巴Java开发手册中强制要求整型包装类对象值用 equals 方法比较？所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。