Java 1.5 introdujo una característica especial de conversión automática de tipos primitivos en la clase Wrapper correspondiente y viceversa.

Boxeo automático: La conversión automática de tipos primitivos en el objeto de las clases contenedoras correspondientes se conoce como autoboxing. Por ejemplo: convertir int a Integer, long a Long, double a Double, etc.

Desembalaje: Este es solo el proceso inverso del autoboxing. La conversión automática de un objeto de una clase contenedora a su tipo primitivo correspondiente se conoce como unboxing. Por ejemplo: convertir Integer a int, Long a long, Double a double, etc.

Primitive type	Wrapper class
boolean	        Boolean
byte	        Byte
char	        Character
float	        Float
int	        Integer
long	        Long
short	        Short
double	        Double

Cuando ocurre el autoboxing y unboxing en Java

Boxeo automático

: Veamos algunos casos con ejemplos, donde se realiza el autoboxing.
Caso 1: Cuando un método espera un objeto de clase contenedora pero el valor pasado como parámetro es un tipo primitivo. Por ejemplo, en el siguiente código, el myMethod() espera un objeto de la clase contenedora Integer, sin embargo, pasamos un tipo int primitivo. El programa funcionó bien ya que el compilador realiza el autoboxing (convirtiendo int a integer)

class AutoboxingExample1
{
   public static void myMethod(Integer num){
	System.out.println(num);
   }
   public static void main(String[] args) {
       /* passed int (primitive type), it would be 
        * converted to Integer object at Runtime
        */
   	myMethod(2);
   }
}

Producción:

2

Caso 2: Cuando en algún momento, asigna un valor de tipo primitivo a un objeto de su clase contenedora. Por ejemplo: Las siguientes declaraciones son válidas porque el compilador realiza el autoboxing en tiempo de ejecución.

Integer inum = 3; //Assigning int to Integer: Autoboxing
Long lnum = 32L; //Assigning long to Long: Autoboxing

Caso 3: Cuando se trata de clases de marco de colección:

ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(11); //Autoboxing - int primitive to Integer
arrayList.add(22); //Autoboxing

Aquí la clase ArrayList espera un objeto de clase contenedora Integer pero estamos proporcionando una primitiva int.

leer  Tutorial de Java Enum con ejemplos

Desembalaje

Caso 1: El método espera un objeto Integer (parámetro) pero hemos proporcionado int. Se produjo un desempaquetado que convirtió Integer en int.

class UnboxingExample1
{
   public static void myMethod(int num){
	System.out.println(num);
   }
   public static void main(String[] args) {
    	
    	Integer inum = new Integer(100);
    	
        /* passed Integer wrapper class object, it 
         * would be converted to int primitive type 
         * at Runtime
         */
    	myMethod(inum);
    }
}

Producción:

100

Caso 2: Tareas

Integer inum = new Integer(5);
int num = inum; //unboxing object to primitive conversion

Caso 3: Mientras administra clases de cobranza:

ArrayList arrayList = new ArrayList()
int num = arrayList.get(0); // unboxing because get method returns an Integer object

¿Qué pasa detrás de escena?

En la sección anterior aprendimos cómo el compilador java realiza la conversión automática entre el tipo primitivo y los objetos envoltorios correspondientes. Hablemos de lo que realmente hace el compilador durante el autoboxing y unboxing. La mejor manera de entender esto es comparar cosas antes de java 1.5 y después de java 1.5 (el boxeo y el unboxing se introdujeron en java 1.5).

Boxeo automático:
Lo que vemos:

Integer number = 100;

Lo que hace el compilador (o lo que hicimos antes de java 1.5):

Integer number = Integer.valueOf(100);

Desembalaje:
Lo que vemos:

Integer num2 = new Integer(50);
int inum = num2;

Qué hace el compilador:

Integer num2 = new Integer(50);
int inum = num2.intValue();

Suceden cosas similares con las otras clases contenedoras y tipos primitivos como long, double, short, etc.

Algunas cosas de las que debes cuidar:

No mezcle primitivas y objetos al comparar. Puede obtener resultados impredecibles para tales comparaciones. Lo mejor que puede hacer es: comparar objetos con objetos (usando el método equals ()) y comparar primitivas con primitivas (usando operadores lógicos como “==”, “<", etc.).

leer  Tutorial de anotación de Java con ejemplos

Referencia

Javadoc – Autoboxing y Unboxing

Por avivcas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *