Java 中的装箱与拆箱
有时,需要将int
这样的基本类型转换为对象。所有基本类型都有一个与之对应的类。例如,Integer
类对应基本类型 int
。 通常, 这些类称为包装器 ( wrapper
), 这些对象包装器类 拥有很明显的名字: Integer
、Long
、Float
、Double
、Short
、Byte
、Character
、Void
和 Boolean
( 前 6 个类派生于公共的超类 Number
)。 对象包装器类是不可变的, 即一旦构造了包装器, 就不允许更改包装在其中的值。同时,对象包装器类还是final
, 因此不能定义它们的子类。
自动装箱
假设想定义一个整型数组列表。而尖括号中的类型参数不允许是基本类型, 也就是说, 不允许写成 ArrayList< int>
。 这里就用到了 Integer
对象包装器类。 我们可以声明一个 Integer
对象的数组列表。
ArrayList<Integer>list = new ArrayList<>();
幸运的是, 有一个很有用的特性, 从而更加便于添加 int
类型的元素到 ArrayList<Integer>
中。 下面这个调用
list.add(3) ;
将自动地变换成
list .add(Integer.value0f (3) ) ;
这种变换被称为自动装箱 (autoboxing
)
自动地拆箱
相反地, 当将一个 Integer
对象赋给一个 int
值时, 将会自动地拆箱。 也就是说, 编译器 将下列语句:
int n = list.get(i);
翻译成
int n = list.get(i).intValue();
注意事项
大多数情况下, 容易有一种假象, 即基本类型与它们的对象包装器是一样的, 只是它们 的相等性不同。大家知道,==
运算符也可以应用于对象包装器对象, 只不过检测的是对象是否指向同一个存储区域, 因此, 下面的比较通常不会成立:
Integer a = 1000;
Integer b = 1000;
System.out.println(a == b); // false
但我们在看一个方法:
Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true
是不是觉得很奇怪?
我们可以通过源码来了解这个问题:
/**
* 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);
}
JVM
会缓存-128
到127
的Integer
对象。当创建新的Integer
对象时,如果符合这个这个范围,并且已有存在的相同值的对象,则返回这个对象,否则创建新的Integer
对象。因此a
和b
实际上是同一个对象。所以使用”==“比较返回true
。