Java基础之自动装箱拆箱

最新推荐文章于 2023-01-09 09:13:16 发布

wingooom

最新推荐文章于 2023-01-09 09:13:16 发布

阅读量260

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/vegetable_bird_001/article/details/50900724

版权

java基础专栏收录该内容

32 篇文章 0 订阅

订阅专栏

概述

自动装箱和拆箱从Java 1.5开始引入

如果你在Java1.5以后进行过编程的话，你一定不会陌生这一点，你不能直接地向集合(Collections)中放入原始(基本)类型值，因为集合只接收对象。通常这种情况下你的做法是，将这些原始类型的值转换成对象，然后将这些转换的对象放入集合中。使用Integer,Double,Boolean等这些类我们可以将原始类型值转换成对应的对象，但是从某些程度可能使得代码不是那么简洁精炼。为了让代码简练，Java 1.5引入了具有在原始类型和对象类型自动转换的装箱和拆箱机制。但是自动装箱和拆箱并非完美，在使用时需要有一些注意事项，如果没有搞明白自动装箱和拆箱，可能会引起难以察觉的bug。

什么是自动装箱拆箱

自动装箱就是Java自动将原始类型值转换成对应的对象，比如将int的变量转换成Integer对象，这个过程叫做装箱，反之将Integer对象转换成int类型值，这个过程叫做拆箱。因为这里的装箱和拆箱是自动进行的非人为转换，所以就称作为自动装箱和拆箱。
原始类型byte,short,char,int,long,float,double和boolean
封装类为Byte,Short,Character,Integer,Long,Float,Double,Boolean。

一般我们要创建一个类的对象实例的时候，我们会这样：

Class a = new Class(parameter);

当我们创建一个Integer对象时，却可以这样：

Integer i = 100; (注意：不是 int i = 100; )

实际上，执行上面那句代码的时候，系统为我们执行了：Integer i = Integer.valueOf(100);

基本数据类型与封装类的差别

基本数据类型不是对象，也就是使用int、double、boolean等定义的变量、常量。

基本数据类型没有可调用的方法。

eg： int t = 1； t. 后面是没有方法滴。

Integer t =1； t. 后面就有很多方法可让你调用了。

什么时候自动装箱

例如：Integer i = 100;

自动装箱主要发生在两种情况，一种是赋值时，另一种是在方法调用的时候

赋值时：相当于编译器自动为您作以下的语法编译：Integer i = Integer.valueOf(100);

方法调用时：

ArrayList<Integer> intList = new ArrayList<Integer>();
intList.add(1); //autoboxing - primitive to object
intList.add(2); //autoboxing

什么时候自动拆箱

自动拆箱(unboxing)，也就是将对象中的基本数据从对象中自动取出。如下可实现自动拆箱：

 Integer i = 10; //装箱 
 int t = i; //拆箱，实际上执行了 int t = i.intValue();

　在进行运算时，也可以进行拆箱。

 Integer i = 10; 
 System.out.println(i++);

自动装箱的弊端

自动装箱有一个问题，那就是在一个循环中进行自动装箱操作的情况，如下面的例子就会创建多余的对象，影响程序的性能。

Integer sum = 0;
 for(int i=1000; i<5000; i++){
   sum+=i;
}

上面的代码sum+=i可以看成sum = sum + i，但是+这个操作符不适用于Integer对象，首先sum进行自动拆箱操作，进行数值相加操作，最后发生自动装箱操作转换成Integer对象。其内部变化如下

int result = sum.intValue() + i;
Integer sum = new Integer(result);

由于我们这里声明的sum为Integer类型，在上面的循环中会创建将近4000个无用的Integer对象，在这样庞大的循环中，会降低程序的性能并且加重了垃圾回收的工作量。因此在我们编程时，需要注意到这一点，正确地声明变量类型，避免因为自动装箱引起的性能问题。

重载与自动装箱

当重载遇上自动装箱时，情况会比较有些复杂，可能会让人产生有些困惑。在1.5之前，value(int)和value(Integer)是完全不相同的方法，开发者不会因为传入是int还是Integer调用哪个方法困惑，但是由于自动装箱和拆箱的引入，处理重载方法时稍微有点复杂。一个典型的例子就是ArrayList的remove方法，它有remove(index)和remove(Object)两种重载，我们可能会有一点小小的困惑，其实这种困惑是可以验证并解开的，通过下面的例子我们可以看到，当出现这种情况时，不会发生自动装箱操作。也就是说test(int num)与 test(Integer num) 符合方法的重载

public void test(int num){
    System.out.println("method with primitive argument");

}

public void test(Integer num){
    System.out.println("method with wrapper argument");

}

//calling overloaded method
AutoboxingTest autoTest = new AutoboxingTest();
int value = 3;
autoTest.test(value); //no autoboxing 
Integer iValue = value;
autoTest.test(iValue); //no autoboxing

Output:
method with primitive argument
method with wrapper argument

对象相等比较

这是一个比较容易出错的地方，”==“可以用于原始值进行比较，也可以用于对象进行比较，当用于对象与对象之间比较时，比较的不是对象代表的值，而是检查两个对象是否是同一对象，这个比较过程中没有自动装箱发生。进行对象值比较不应该使用”==“，而应该使用对象对应的equals方法。

Integer.ValueOf(int)和new Integer(int)性能比较

Integer.ValueOf(int)源码

public static Integer valueOf(int i) {  
    final int offset = 128;  
    if (i >= -128 && i <= 127) { // must cache  
        return IntegerCache.cache[i + offset];  
    }  
    return new Integer(i);  
}  

private static class IntegerCache {  
    private IntegerCache() {  
    }  

    static final Integer cache[] = new Integer[-(-128) + 127 + 1];  

    static {  
        for (int i = 0; i < cache.length; i++)  
            cache[i] = new Integer(i - 128);  
    }  
}

从源代码可以知道，ValueOf对-128～127这256个值做了缓存(IntegerCache)，如果int值的范围是：-128～127，在ValueOf(int)时，直接返回IntegerCache的缓存值。

public static void main(String[] args) {  


            Integer a = 100;  
            Integer b = 100;  
            System.out.println(a == b);  
            Integer c = new Integer(100);  
            Integer d = new Integer(100);  
            System.out.println(c == d);  

            Integer e = 200;  
            Integer f = 200; 
            System.out.println(e == f); 
}