本文主要是介绍Java自动装箱和自动拆箱源码分析，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
自动装箱（boxing）和自动拆箱（unboxing）
| 基本类型 | 占用空间（Byte） | 表示范围 | 包装器类型 |
| boolean | 1/8 | true|false | Boolean |
| char | 2 | -128~127 | Character |
| byte | 1 | -128~127 | Byte |
| short | 2 | -2ˆ15~2ˆ15-1 | Short |
| int | 4 | -2ˆ31~2ˆ31-1 | Integer |
| long | 8 | -2ˆ63~2ˆ63-1 | Long |
| float | 4 | -3.403E38~3.403E38 | Float |
| double | 8 | -1.798E308~1.798E308 | Double |
自动装箱
Java中所谓的装箱通俗点就是：八种基本数据类型在某些条件下使用时，会自动变为对应的包装器类型。
如下清单1：
| 1 2 3 4 5 6 7 8 9 10 11 12 | @Test public void boxingTest() { Integer i1 = 17 ; Integer i2 = 17 ; Integer i3 = 137 ; Integer i4 = 137 ; System.out.println(i1 == i2); 11 System.out.println(i3 == i4); } |
输出：
| 1 2 | true false |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | /** * 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); } |
从源码中可以看出，Integer对象自动缓存int值范围在low~high（-128~127），如果超出这个范围则会自动装箱为包装类。
Note:
- Integer、Short、Byte、Character、Long这几个包装类的valueOf方法的实现是类似的；
- Double、Float的valueOf方法的实现是类似的。
- Boolean的valueOf方法的实现是个三目运算，形如` return (b ? TRUE : FALSE); `
自动拆箱
Java中所谓的拆箱通俗点就是：八种包装器类型在某些条件下使用时，会自动变为对应的基本数据类型。
清单2：
| 1 2 3 4 5 6 7 8 9 10 11 12 | @Test public void unboxingTest() { Integer i1 = 17 ; int i2 = 17 ; int i3 = 137 ; Integer i4 = 137 ; System.out.println(i1 == i2); 10 System.out.println(i3 == i4); } |
输出：
| 1 2 | true true |
解释下清单2第10句输出true的原因：
当程序执行到第10句时，i4会调用Integer.intValue方法自动拆箱包装器类型为基本数据类型。
| 1 2 3 4 5 6 7 | /** * Returns the value of this {@code Integer} as an * {@code int}. */ public int intValue() { return value; } |
从源码可以看出，当包装器类型和基本数据类型进行“==”比较时，包装器类型会自动拆箱为基本数据类型。
清单3内容如下：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | @Test public void unboxingTest() { Integer i1 = 17 ; Integer i2 = 17 ; Integer i3 = 137 ; Integer i4 = 137 ; // == System.out.println(i1 == i2); System.out.println(i3 == i4); // equals System.out.println(i1.equals(i2)); 15 System.out.println(i3.equals(i4)); } |
输出：
| 1 2 3 4 | true false true true |
解释第15句为什么会输出true：
因为在Integer包装类实现的equals方法中，只要比较的当前对象是Integer实例，那么就会自动拆箱为基本数据类型。从以下Integer类的equals方法的源码就可看出：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | /** * Compares this object to the specified object. The result is * {@code true} if and only if the argument is not * {@code null} and is an {@code Integer} object that * contains the same {@code int} value as this object. * * @param obj the object to compare with. * @return {@code true} if the objects are the same; * {@code false} otherwise. */ public boolean equals(Object obj) { if (obj instanceof Integer) { return value == ((Integer)obj).intValue(); } return false ; } |
Note:
- Integer、Short、Byte、Character、Long这几个包装类的intValue方法的实现是类似的；
- Double、Float的intValue方法的实现是类似的。
- Boolean的booleanValue方法的实现和intValue方法的实现也是类似的。
装箱拆箱综合清单：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | public static void main(String args[]) { Integer a = 1 ; Integer b = 2 ; Integer c = 3 ; Integer d = 3 ; Integer e = 321 ; Integer f = 321 ; Long g = 3L; Long h = 2L; // 会自动拆箱（会调用intValue方法） System.out.println(c==d); // 会自动拆箱后再自动装箱 System.out.println(e==f); // 虽然“==”比较的是引用的是否是同一对象，但这里有算术运算，如果该引用为包装器类型则会导致自动拆箱 System.out.println(c==(a+b)); // equals 比较的是引用的对象的内容（值）是否相等，但这里有算术运算，如果该引用为包装器类型则会导 // 致自动拆箱，再自动装箱 // a+b触发自动拆箱得到值后，再自动装箱与c比较 System.out.println(c.equals(a+b)); // 首先a+b触发自动拆箱后值为int型，所以比较的是值是否相等 System.out.println(g==(a+b)); // 首先a+b触发自动拆箱后值为int型，自动装箱后为Integer型，然后g为Long型 System.out.println(g.equals(a+b)); // 首先a+h触发自动拆箱后值为long型，因为int型的a会自动转型为long型的g然后自动装箱后为Long型， // 而g也为Long型 System.out.println(g.equals(a+h)); } |
输出：
| 1 2 3 4 5 6 7 | true false true true true false true |
这篇关于Java自动装箱和自动拆箱源码分析的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
