Java 中的自动装箱和拆箱

Java 3周前 10

自动装箱将原始数据类型转换为其等效的包装器类型，而拆箱是将包装器类型转换为原始数据类型。此功能内置在 Java 中。

本教程描述并演示了在 Java 中使用自动装箱和拆箱。

Java 中的自动装箱

如上所述，自动装箱将原始数据类型转换为与对象相同的包装类型类。例如，long 到 Long 或 int 到 Integer。

这些原始数据类型及其对应的包装类型类的列表如下。

原始类型	封装器类型
`int`	`Integer`
`boolean`	`Boolean`
`double`	`Double`
`float`	`Float`
`byte`	`Byte`
`char`	`Character`
`long`	`Long`
`short`	`Short`

我们可以在 Java 中使用自动装箱的三种情况：

我们必须将原始数据类型作为参数传递给任何方法。该方法需要一个相应的包装类对象。
将原始数据类型分配给具有相应包装类的变量时。
在使用集合框架类时，编译器必须在 Java 中执行自动装箱。

有三种情况。让我们尝试为每种情况创建一个示例。请参阅第一种情况的示例：

package Delfstack;
public class Autoboxing_Test{
    public static void Number(Integer x){
        System.out.println(x);
    }
    public static void main(String[] args){
    	// Compiler performs Autoboxing here. it converts primitive type to wrapper type Integer object.
        int x= 10;
    	Number(x);
    }
}

我们将原始类型 int 作为参数传递给需要包装类 Integer 的方法；编译器将在此处执行自动装箱。见输出：

请参阅第二种情况的示例：

package Delfstack;
public class Autoboxing_Test{
    public static void main(String[] args){
        // Assigning primitive long value to Wrapper Long variable x. Compiler performs autoboxing
        Long x = 430L;
        // Assigning primitive char value to Wrapper Character variable y. Compiler performs autoboxing
        Character y = 'a';
        System.out.println(x);
        System.out.println(y);
    }
}

我们将原始数据类型值分配给包装器类型变量，编译器执行自动装箱。见输出：

430
a

请参见第三种情况的示例：

package Delfstack;
import java.util.ArrayList;
public class Autoboxing_Test{
    public static void main(String[] args){
        ArrayList<Long> Long_List = new ArrayList<Long>();
        //while working with collections framework the compiler performs autoboxing
        Long_List.add(220L);
        Long_List.add(330L);
        System.out.println(Long_List);
    }
}

在使用集合框架类时，编译器必须像上面的代码一样在 Java 中执行自动装箱；我们将原始类型 long 元素添加到包装类型 Long 列表中。见输出：

[220, 330]

Java 中的拆箱

Java 中的拆箱将包装类的对象转换为相同的原始数据类型；这是自动装箱的相反操作。例如，将 Integer 转换为 int 或 Long 转换为 long，前面的表格也可以用于装箱，反之亦然。

拆箱也可以应用于三种情况：

将包装类的对象传递给需要原始类型值的方法时。
当包装类对象被赋值给对应的原始变量时。
在使用集合框架时。

让我们为 Java 中的每种情况尝试一个示例。请参阅第一种情况的示例：

package Delfstack;
public class Unboxing_Test {
    public static void Number(int x){
        System.out.println(x);
    }
    public static void main(String[] args){
        Integer x = new Integer(340);
        // We passed Integer wrapper class object, the compiler will convert it to int because method requires int
        Number(x);
    }
}

编译器将在将包装类的对象传递给需要原始类型值的方法时执行拆箱。见输出：

第二种情况的例子：

package Delfstack;
public class Unboxing_Test {
    public static void main(String[] args)
    {
        Long x = new Long(340L);
        Integer y = new Integer(450);
        // Performing unboxing here. assigning Long object to primitive long type similarly Integer to int
        long a = x;
        int b = y;
        System.out.println(a);
        System.out.println(b);
    }
}

当包装类对象分配给相应的原始变量时，编译器将执行拆箱。见输出：

340
450

第三种情况的示例：

package Delfstack;
import java.util.ArrayList;
public class Unboxing_Test {
    public static void main(String[] args)
    {
        ArrayList<Long> Long_List = new ArrayList<Long>();
        Long_List.add(230L);
        Long_List.add(340L);
        Long_List.add(450L);
        // The get method returns an Long object and we assigned it to the long primitive type
        long x = (long) Long_List.get(0);
        long y = (long) Long_List.get(1);
        long z = (long) Long_List.get(2);
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
    }
}