Java自动装箱和自动拆箱

最新推荐文章于 2025-08-08 14:35:44 发布

大树叶

最新推荐文章于 2025-08-08 14:35:44 发布

阅读量371

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java 装箱拆箱

本文链接：https://blog.youkuaiyun.com/bigtree_3721/article/details/74572233

java 专栏收录该内容

494 篇文章

订阅专栏

本文详细解析了Java中自动装箱与拆箱的过程及其实现机制，对比了内置类型与包装器类型的性能差异，并通过具体示例展示了常见的面试题解答。

定义：

自动装箱：Java自动将原始数据类型转化为相应的包装类对象，例如，把int转化为Integer。

拆箱：自动装箱的反过程，相应的包装类对象转化为原始数据类型，例如，把Integer转为int。

内置类型和包装器
内置类型	包装器类型
boolean	Boolean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
void	Void

实现机制：

当发生自动装箱时，编译器自动调用了valueOf()方法，得到相应的包装器对象，当发生拆装时，编译器自动调用了xxxValue()方法（例如IntValue，LongValue等）。

如若想确认是否调用了相应的方法，可以在相应的位置设置断点，debug一下就能看到进入相应的方法。

使用java自带的javap反编译工具也能看得出来。

性能的比较：

自动装箱和拆箱是编译器分别通过自动调用valueOf()和xxxValue()来实现的，使用包装器类型和直接使用基本数据类型上就会有一性能的差距。

[java]view plaincopy 
    
print?
 Long sum = new Long(0);//sum是包装器Long  
 for(long i=0;i<Integer.MAX_VALUE;i++){  
      sum += i;  
 }  
 windows7, I5的处理器，4G的内存，时间:11S  
   
 long sum = new Long(0);//sum是基本类型long  
 for(long i=0;i<Integer.MAX_VALUE;i++){  
      sum += i;  
 }  
 windows7, I5的处理器，4G的内存，时间:1S  

从结果可以看出，时间上相差10秒，差距还是不小的。

常见面试题目：

题目1：

[java]view plaincopy 
    
print?
 public class App {  
         public static void main(String[] args) {  
               Integer i1 = 127;  
               Integer i2 = 127;  
               Integer i3 = 128;  
               Integer i4 = 128;  
                 
               System. out.println(i1 == i2);  
               System. out.println(i3 == i4);  
        }  
   
 }  

程序的输出是什么呢，如果你的答案是true，true的话，以下就值得这你留步了。程序的输出是true，false。

我们先看源代码：

[java]view plaincopy 
    
print?
 public static Integer valueOf(int i) {  
     assert IntegerCache.high >= 127;  
     if (i >= IntegerCache.low && i <= IntegerCache. high)  
         return IntegerCache.cache[i + (-IntegerCache.low)];  
     return new Integer(i);  
 }  

在Integer里，valueOf是以上这样实现的，为了降低内存占用和垃圾回收的成本，类库里增加了一个cache，保存常用的int包装器对象(-128　~ 127),当数值在这个范围时，就从cache里取出对象，所以i1和i2指同一个内在块，输出就为true。而i3和i4的值大于127，就不会在这个cache里取值，重新new一个对象，因此不是同一个内存块，输出就为false。

Integer和Long都是使用了cache机制，所以在　-128　~ 127　之间，比较都为true,

但是Integer的cache大小可以通过参数来改变，但是Long却不行。

 
 -Djava.lang.Integer.IntegerCache.high=300  
 -Djava.lang.Integer.IntegerCache.low=-300  
   
 Boolean也使用了cache的机制，源代码如下：  
 public static final Boolean TRUE = new Boolean(true);  
 public static final Boolean FALSE = new Boolean(false);  
   
 public static Boolean valueOf(boolean b) {  
     return (b ? TRUE : FALSE);  
 }

题目2：

 
    
 
   
 public class Main {  
     public static void main(String[] args) {  
         Integer a = 1;  
         Integer b = 2;  
         Integer c = 3;  
         Long g = 3L;  
         Long h = 2L;  
   
         System.out.println(c==(a+b));//1  
         System.out.println(c.equals(a+b));//2  
         System.out.println(g==(a+b));//3  
         System.out.println(g.equals(a+b));//4  
         System.out.println(g.equals(a+h));//5  
     }  
 }  

输出:

true

false

true

a拆箱，b拆箱，相加结果为int，c拆箱，int和int相比较.
a拆箱，b拆箱，相加结果为int,方法equals的参数是Object，所以int又要装箱，引用比较，又因为数据3在cache里，所以为true.
a拆箱，b拆箱，相加结果为int，转化为long型,g拆箱，数值相比较，为true.
a拆箱，b拆箱，相加结果为int，方法equals的参数是Object，所以int又要装箱为Integer，Long和Integer比较，所以为false.
a拆箱，b拆箱，相加结果为long，方法equals的参数是Object，所以要装箱为Long，Long和Long相比较，所以为true。

从以上测试中，可以得出以下结论：

１：当基本数据类型和包装器类型

做　==，　 +　和　-　运算时，包装器类型会拆箱为基本数据类型，再做运算。

陷阱1

[java]view plaincopy 
    
 Integer integer100=null;  
 int int100=integer100;  

这两行代码是完全合法的，完全能够通过编译的，但是在运行时，就会抛出空指针异常。其中，integer100为Integer类型的对象，它当然可以指向null。但在第二行时，就会对integer100进行拆箱，也就是对一个null对象执行intValue()方法，当然会抛出空指针异常。所以，有拆箱操作时一定要特别注意封装类对象是否为null。

陷阱２

由于JDK的８个包装类和String 都是不可变类，即被创建后，实例的实例变量不可以改。

ong t = System.currentTimeMillis();
Long sum = 0L;for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;
}
System.out.println("total:" + sum);
System.out.println("processing time: " + (System.currentTimeMillis() - t) + " ms");

输出结果：
总数：2305843005992468481
处理时间：6756 ms

仔细琢磨一下，你可能会想到下面这种执行速度更快的实现方法：

long t = System.currentTimeMillis();//Long sum = 0L;

long sum = 0L;for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;
}
System.out.println("total:" + sum);
System.out.println("processing time: " + (System.currentTimeMillis() - t) + " ms") ;

输出结果：
总数：2305843005992468481
处理时间：1248 ms

为啥？因为Long包装类是不可变类，因此，前文出现的第一段代码段会自动转化为如下代码。所以，导致处理时间较长的原因也就水落石出了：不必要地创建了2147483647个”Long“类型实例。

long t = System.currentTimeMillis();
Long sum = 0L;for (long i = 0; i < Integer.MAX_VALUE; i++) {
sum += new Long(i);
}
System.out.println("total:" + sum);
System.out.println("processing time: " + (System.currentTimeMillis() - t) + " ms") ;