Java基础类型的自动装箱拆箱

女爷i 2023-06-14 10:59 30阅读 0赞

### 自动装箱拆箱 ###

*   *   *   *  1.1、类型封装器
             *   *  1.1.1、Character封装器
                 *  1.1.2、Boolean封装器
                 *  1.1.3、数值类型封装器
             *  1.2、自动装箱
             *   *  1.2.1、自动装箱与方法
                 *  1.2.2、表达式中发生的自动装箱/拆箱
                 *  1.2.3、布尔型和字符型数值的自动装箱/拆箱
                 *  1.2.4、自动装箱/拆箱有助于防止错误
                 *  1.2.5、一些警告

#### 1.1、类型封装器 ####

Java使用基本类型(也称为简单类型，比如int或double)来保存语言支持的基本数据类型。由于性能考虑，为这些数据使用基本类型而不是对象。为这些数据使用对象，即使是最简单的计算也会增加不可接受的开销。因此，基本类型不是对象层次的组成部分，它们不继承Object类。  
虽然基本类型提供了性能方面的好处，但有时会需要对象这种表示形式。例如，不能通过引用为方法传递基本类型。此外，Java实现的许多标准数据结构是针对对象进行操作的，这意味着不能使用这些结构存储基本类型。为了处理这些(以及其他)情况，Java提供了类型封装器，用来将基本类型封装到对象中。  
类型封装器包括Double、Float、Long、Integer、Short、Byte、Character以及Boolean。这些类提供了大量的方法，通过这些方法可以完全将基本类型集成到Java的对象层次中。下面对这些封装器逐一进行简要介绍。

##### 1.1.1、Character封装器 #####

Character是char类型的封装器。Character的构造函数为:

Character(char ch)//ch指定了由即将创建的Character对象封装的字符。

为了获取Character对象中的char值，可以调用charValue()方法，如下所示：

char charValue()//该方法返回封装的字符。

##### 1.1.2、Boolean封装器 #####

Boolean是用来封装布尔值的封装器，其中定义了以下构造函数：

Boolean(boolean boolValue)//boolValue必须是true或false
    Boolean(String boolString)//如果boolString包含字符串"true"(大写或小写形式都可以)，那么新的Boolean对象将为true,否则将为false

为了从Boolean对象获取布尔值，可以使用booleanValue()方法，如下所示：

boolean booleanValue()//返回与调用对象等价的布尔值

##### 1.1.3、数值类型封装器 #####

到目前为止，最常用的类型封装器是那些表示数值的封装器，包括Byte、Short、Integer、Long、Float以及Double。所有这些数值类型封装器都继承自抽象类Number。Number声明了以不同数字格式从对象返回数值的方式，如下所示：

byte byteValue()
    double doubleValue()
    float floatValue()
    int intValue()
    long longValue()
    short shortValue()

例如，doubleValue()方法返回double类型的值，floatValue()方法返回float类型的值，等等。每个数值类型封装器都实现了这些方法。  
所有数值类型封装器都定义了用于从给定数值或数值的字符串表示形式构造对象的构造函数。例如，下面是为Integer定义的构造函数：

Integer(int num)
    Integer(String str)

如果str没有包含有效地数值，就会抛出NumberFormatException异常。  
所有类型封装器都重写了toString()方法，用来返回封装器所包含的人类可以阅读的形式，从而可以通过将封装器对象传递给println()方法来输出数值。例如，不必将之转换为基本类型。  
下面的程序演示了如何使用数值类型的封装器封装数值以及如何提取数值：

//Demostrate a type wrapper.
    public class Warp {
        
        public static void main(String[] args) {
        
            Integer iOb = new Integer(100);
            int i =iOb.intValue();
            System.out.println(i+" "+iOb);//displays 100 100
        }
    }

这个程序将整型值100封装到Integer对象iOb中，然后程序调用intValue()方法以获取这个数值，并将结果存储到i中。  
将数值封装到对象中的过程称为装箱。Integer iOb = new Integer(100)将数值100装箱到Integer对象中。  
从类型封装器中抽取数值的过程称为拆箱。 int i =iOb.intValue();拆箱iOb中的数值。  
上述程序使用的装箱和拆箱数值的一般过程，在Java原始版本中就已经提供了。但是，自JDK5以后，Java通过自动装箱从根本上改进了这一过程。

#### 1.2、自动装箱 ####

自JDK5开始，Java增加了两个重要的特性：自动装箱和自动拆箱。自动装箱是这样一个过程：无论何时，只要需要基本类型的对象，就自动将基本类型自动封装(装箱)到与之等价的类型封装器中，而不需要显示地构造对象。自动拆箱是当需要时自动抽取(拆箱)已装箱对象的数值的过程。不需要调用intValue()或doubleValue()这类方法。  
自动装箱和自动拆箱特性极大地简化了一些算法的编码，移除了单调乏味的手动装箱和拆箱数值操作。它们还有助于防止错误发生。此外，它们对泛型非常重要，因为泛型只能操作对象。最后，集合框架需要利用自动装箱特性进行工作。  
有了自动装箱特性，封装基本类型将不必再手动创建对象。只需要将数值赋给类型封装器引用即可，Java会自动创建对象。例如，下面是构造具有数值100的Integer对象的现代方式：

Integer iOb = 100;// autobox an int

注意，没有使用new显示地创建对象。Java自动处理了这个过程。  
为了拆箱对象，可以简单地将对象引用赋值给基本类型的变量。例如，为了拆箱iOb,可以使用下面这行代码，Java处理了这一过程的细节：

int i = iOb;// auto-unbox

下面的程序对前面的程序进行了改写，以使用自动装箱和自动拆箱的特性：

//Demonstrate autoboxing/unboxing.
    class AutoBox{
        
      public static void main(String args[]){
        
        Integer iOb = 100; //autobox an int
        int i = iOb;//auto-unbox
        System.out.println(i+" "+iOb);//displays 100 100
      }
    }

##### 1.2.1、自动装箱与方法 #####

除了赋值这种简单情况之外，无论何时，如何必须将基本类型转换为对象，就会发生自动装箱；无论何时，如果对象必须转换为基本类型就会发生自动拆箱。因此，当向方法传递参数或从方法返回数值时，都可能会发生自动装箱/拆箱。例如，分析下面的程序：

//Autoboxing/unboxing takes place with method parameters and return values.
    public class AutoBox2 {
        
        //Take an Integer parameter and return an int value;
        static int m(Integer v) {
        
            return v;//auto-unbox to int
        }
    
        public static void main(String[] args) {
        
            //Pass an int to m() and assign the return value
            //to an Integer.Here,the argument 100 is autoboxed
            //into an Integer.The return value is also autoboxed into an Integer
            Integer iOb = m(100);
            System.out.println(iOb);
            /**
             * 输出结果：
             * 100
             */
        }
    }

##### 1.2.2、表达式中发生的自动装箱/拆箱 #####

通常无论何时，当需要将基本类型转换为对象或将对象转换为基本类型时，就会发生自动装箱和自动拆箱。对于表达式也是如此。在表达式中，数值对象会被自动拆箱。如果需要的话，还可以对表达式的输出进行重新装箱。例如，分析下面的程序：

//Autoboxing/unboxing occurs inside expressions.
    public class AutoBox3 {
        
        public static void main(String[] args) {
        
            Integer iOb, iOb2;
            int i;
            iOb = 100;
            System.out.println("Original value of iOb: " + iOb);
            //The following automatically unboxes iOb,
            //performs the increment,and then reboxes
            //the result back into iOb.
            ++iOb;
            System.out.println("After ++iOb: " + iOb);
            //Here,iOb is unboxed,the expression is
            //evaluted,and the result is reboxed and
            //assign to iOb2.
            iOb2 = iOb + (iOb / 3);
            System.out.println("iOb2 after expression: " + iOb2);
            //The same expression is evaluated,but the
            //result is not reboxed
            i = iOb + (iOb / 3);
            System.out.println("i After expression: " + i);
            /**
             * 输出结果：
             * Original value of iOb: 100
             * After ++iOb: 101
             * iOb2 after expression: 134
             * i After expression: 134
             */
        }
    }

\++iOb会导致iOb中的值递增。具体工作过程如下：将iOb自动拆箱，将值递增，然后将结果自动装箱。  
自动拆箱还允许在表达式中混合不同数值类型的对象。一旦数值被拆箱，就会应用标准的类型提升和转换。例如，下面的程序时完全合法的：

public class AutoBox4 {
        
        public static void main(String[] args) {
        
            Integer iOb = 100;
            Double dOb = 98.6;
            dOb = dOb + iOb;
            System.out.println("dOb after expression: " + dOb);
            /**
             * 输出结果：
             * dOb after expression: 198.6
             */
        }
    }

可以看出,Double对象dOb和Integer对象iOb都参与了加法运算，对结果再次装箱并存储到dOb中。  
因为提供了自动拆箱特性，所以可以使用Integer数值对象控制switch语句，例如，分析下面的代码段：

Integer iOb = 2;
    switch(iOb){
        
     case 1:System.out.println("one");
      break;
     case 2:System.out.println("two");
      break;
     default:System.out.println("error");
    }

当对switch表达式进行求值时，iOb被拆箱，从而得到其中存储int型数值。  
正如程序中的例子所显示的，因为提供了自动装箱/拆箱的特性，在表达式中使用数值类型对象不仅很直观而且很容易。在过去，这种代码需要涉及强制类型转换，并且需要调用intValue()这类方法。

##### 1.2.3、布尔型和字符型数值的自动装箱/拆箱 #####

如前所述，Java也为布尔和字符类型提供了封装器，它们是Boolean和Character。这些封装器也应用自动装箱/拆箱特性。例如，分析下面的程序：

//Autoboxing/unboxing a Boolean and Character.
    public class AutoBox5 {
        
        public static void main(String[] args) {
        
            //Autobox/unbox a boolean
            Boolean b = true;
            //Below,b i a auto-unboxed when used in
            //a conditional expression,such as an if.
            if (b) System.out.println("b is true");
            //Autobox/unbox a char.
            Character ch = 'x';//box a char
            char ch2 = ch;//unbox a char
            System.out.println("ch2 is " + ch2);
            /**
             * 输出结果
             * b is true
             * ch2 is x
             */
        }
    }

在if条件表达式中对b进行自动拆箱。控制if的条件表达式的求值结果必须是布尔类型的。因此，有了自动拆箱特性，当对条件表达式进行求值时，b中的布尔值被自动拆箱。因此，因为提供了自动装箱/拆箱特性，所以在if语句中可以使用Boolean对象。  
正是因为有了自动拆箱特性，现在也可以使用Boolean对象控制所有循环语句。当将Boolean对象用作while、for或do/while的条件表达式时，会自动拆箱为它的布尔等价形式。例如，现在下面的代码是合法的：

Boolean b
    while(b){
        //...

##### 1.2.4、自动装箱/拆箱有助于防止错误 #####

除了可以提供便利之外，自动装箱/拆箱还有助于防止错误。例如，分析下面的代码：

//An error produced by manual unboxing.
    public class UnboxingError {
        
        public static void main(String[] args) {
        
            Integer iOb=1000;//autobox the value 1000
            int i=iOb.byteValue();//manually
            System.out.println(i);//does not display 1000 !
        }
    }

该程序不会显示期望的数值1000，而会显示-24！原因是：通过byteValue()方法对iOb中的值进行手动拆箱，会导致存储在iOb中的值(1000)被截断。结果是将垃圾值-24赋给i。自动拆箱可以防止这种类型的错误发生，因为iOb中的值总会被拆箱到与int类型兼容的值。  
通常，因为自动装箱总是会创建正确的对象，并且自动拆箱总会产生正确的数值，所以不会产生错误类型对象或数值。如果我们所期望的类型和自动装箱/拆箱生成的类型不同的话，仍然可以对数值进行手动装箱/拆箱。当然，这种丢失自动装箱/拆箱带来的好书。通常，编写现代Java代码应当使用自动装箱/拆箱。

##### 1.2.5、一些警告 #####

即使Java提供了自动装箱/拆箱特性，但是我们不能专门使用Integer或Double，而完全放弃基本类型。例如，可能使用自动装箱/拆箱编写类似下面的代码：

//A bad use of autoboxing/unboxing!
    Double a,b,c;
    a = 10.0;
    b = 4.0;
    c = Math.sqrt(a*a + b*b);
    System.out.println("Hypotenuse is "+c);

在这个例子中，使用double类型的对象保存用于计算直角三角形斜边的值。尽管这段代码从技术上讲是正确的，并且可以工作，实际工作的很好，但这是对自动装箱/拆箱的滥用。与使用基本类型的double编写的等价代码相比，上面代码的效率低很多。原因是每次进行自动装箱/拆箱都会增加开销，而使用基本类型不需要这些开销。  
通常，应当限制类型封装器的使用，只有当需要基本类型的对象表示形式时才应当使用。