Autoboxing y Unboxing en Java

1. Boxeo automático en Java
2. Desembalaje en Java

Autoboxing convierte tipos de datos primitivos en su tipo contenedor equivalente, y unboxing es la conversión de tipos contenedor a tipos de datos primitivos. Esta función está integrada en Java.

Este tutorial describe y demuestra el uso de auto-boxing y unboxing en Java.

Boxeo automático en Java

Como se mencionó anteriormente, el encuadre automático convierte los tipos de datos primitivos en la misma clase de tipo contenedor que un objeto. Por ejemplo, long a Long o int a Integer.

La lista de estos tipos de datos primitivos y su clase de tipo contenedor correspondiente se encuentra a continuación.

Hay tres casos en los que podemos usar el auto-boxing en Java:

1. Debemos pasar un tipo de dato primitivo como parámetro en cualquier método. Ese método requiere un objeto de clase contenedora correspondiente.
2. Al asignar un tipo de datos primitivo a una variable con una clase contenedora correspondiente.
3. Mientras trabaja con las clases del marco de la colección, el compilador debe realizar el autoboxing en Java.

Hay tres casos. Intentemos crear un ejemplo para cada caso. Vea el ejemplo para el primer caso:

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);
  }
}

Pasamos un tipo primitivo int como parámetro a un método que requiere la clase contenedora Integer; el compilador realizará el autoboxing aquí. Ver salida:

10

Ver el ejemplo para el segundo caso:

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);
  }
}

Asignamos valores de tipo de datos primitivos a la variable de tipo contenedor y el compilador realizó el autoboxeo. Ver salida:

430
a

Vea el ejemplo para el tercer caso:

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);
  }
}

Mientras trabaja con clases de marco de colección, el compilador debe realizar el autoboxing en Java como en el código anterior; añadimos elementos de tipo primitivo long a la lista Long de tipo contenedor. Ver salida:

[220, 330]

Desembalaje en Java

El unboxing en Java convierte un objeto de una clase contenedora al mismo tipo de datos primitivo; es la operación opuesta al autoboxing. Por ejemplo, al convertir Integer en int o Long en long, la tabla anterior también se puede usar para el boxeo y viceversa.

El unboxing también se puede aplicar en tres casos:

1. Al pasar un objeto de una clase contenedora a un método que requiere un valor con tipo primitivo.
2. Cuando el objeto de la clase contenedora se asigna a la variable primitiva correspondiente.
3. Mientras se trabaja con marcos de colección.

Probemos un ejemplo para cada caso en Java. Vea el ejemplo para el primer caso:

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);
  }
}

El compilador realizará el desempaquetado mientras pasa un objeto de una clase contenedora a un método que requiere un valor con un tipo primitivo. Ver salida:

340

El ejemplo para el segundo caso:

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);
  }
}

El compilador realizará el desempaquetado cuando el objeto de la clase contenedora se asigne a la variable primitiva correspondiente. Ver salida:

340
450

El ejemplo para el tercer caso:

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);
  }
}

Mientras se trabaja con marcos de colección como ArrayList, el compilador realiza unboxing cuando intentamos asignar elementos de la lista ArrayList a variables de tipo primitivo. Ver salida:

230
340
450