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.
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.).