Autoboxing y unboxing en Java

En este artículo veremos una característica de Java llamada autoboxing/unboxing . Autoboxing y unboxing es una función de convertir tipos primitivos en tipos de objetos y viceversa. Todo el proceso lo realiza automáticamente Java Runtime Environment (JRE). Pero debes tener cuidado al implementar esta función, porque... Puede afectar el rendimiento de su programa.

Introducción

En versiones inferiores a JDK 1.5, no era fácil convertir tipos de datos primitivos como int,,, a charsus clases contenedoras Integer, Character, Float, Double. A partir de JDK 5, esta funcionalidad, que convierte tipos primitivos en objetos equivalentes, se implementa automáticamente. Esta propiedad se conoce como Autoboxing . El proceso inverso, respectivamente, es Unboxing , es decir. el proceso de convertir objetos en sus correspondientes tipos primitivos. A continuación se proporciona un código de muestra para autoboxing y unboxing: Autoboxingfloatdouble

Integer integer = 9;

Desembalaje

int in = 0;
in = new Integer(9);

¿Cuándo se utiliza el embalaje y desembalaje automático? El compilador de Java utiliza el autoboxing en las siguientes condiciones:

• Cuando un valor de un tipo primitivo se pasa a un método como parámetro de método, se espera un objeto de la clase contenedora correspondiente.
• Cuando un valor de un tipo primitivo se asigna a una variable de la clase contenedora correspondiente.

Considere el siguiente ejemplo: Listado 1: Código simple que muestra el autoboxing

public int sumEvenNumbers(List<Integer> intList ) {
int sum = 0;
for (Integer i: intList )
if ( i % 2 == 0 )
sum += i;
return sum;
}

Antes de jdk 1.5, el código anterior habría causado un error de compilación porque el operador restante % y unario más += no se podían aplicar a una clase contenedora. Pero en jdk 1.5 y superiores, este código se compila sin errores y convierte Integer a int. El compilador de Java utiliza el unboxing en las siguientes condiciones:

• Cuando un objeto se pasa como parámetro a un método que espera un tipo primitivo correspondiente.
• Cuando un objeto se asigna a una variable del tipo primitivo correspondiente.

Considere el siguiente ejemplo: Listado 2: Código simple que muestra unboxing

import java.util.ArrayList;
import java.util.List;

public class UnboxingCheck {

public static void main(String[] args) {
Integer in = new Integer(-8);

// 1. Распаковка через вызов метода
int absVal = absoluteValue(in);
System.out.println("absolute value of " + in + " = " + absVal);

List<Double> doubleList = new ArrayList<Double>();

// Автоупаковка через вызов метода
doubleList.add(3.1416);

// 2. Распаковка через присвоение
double phi = doubleList.get(0);
System.out.println("phi = " + phi);
}

public static int absoluteValue(int i) {
return (i < 0) ? -i : i;
}
}

El autoboxing y unboxing permiten al desarrollador escribir código que sea fácil de leer y comprender. La siguiente tabla muestra los tipos de datos primitivos y sus correspondientes objetos contenedores. Tabla 1: Tipos primitivos y clases contenedoras equivalentes con operadores de comparación Autoboxing y unboxing se pueden utilizar con operadores de comparación. El siguiente fragmento de código ilustra cómo sucede esto: Listado 3: Código de muestra que muestra el autoboxing y unboxing con un operador de comparación

public class BoxedComparator {
  public static void main(String[] args) {
      Integer in = new Integer(25);
      if (in < 35)
          System.out.println("Value of int = " + in);
  }
}

Empaquetado y desempaquetado automático al sobrecargar un método. El empaquetado y desempaquetado automático se realiza cuando se sobrecarga un método según las siguientes reglas:

• La expansión “derrota” al embalaje en una situación en la que hay que elegir entre expansión y embalaje; la expansión es preferible.

Listado 4: Código de muestra que muestra el beneficio de la sobrecarga

public class WideBoxed {
  public class WideBoxed {
  static void methodWide(int i) {
       System.out.println("int");
   }

  static void methodWide( Integer i ) {
      System.out.println("Integer");
  }

  public static void main(String[] args) {
      short shVal = 25;
      methodWide(shVal);
  }
 }
}

Salida del programa - tipoint

• La expansión supera a un número variable de argumentos En una situación en la que hay que elegir entre expansión y un número variable de argumentos, es preferible la expansión.

Listado 5: Código de muestra que muestra el beneficio de la sobrecarga

public class WideVarArgs {

    static void methodWideVar(int i1, int i2) {
      System.out.println("int int");
    }

    static void methodWideVar(Integer... i) {
       System.out.println("Integers");
    }

   public static void main( String[] args) {
       short shVal1 = 25;
      short shVal2 = 35;
     methodWideVar( shVal1, shVal2);
   }
  }

• El empaquetado supera a un número variable de argumentos En una situación en la que hay que elegir entre empaquetado y un número variable de argumentos, es preferible el empaquetado.

Listado 6: Código de muestra que muestra el beneficio de la sobrecarga

public class BoxVarargs {
     static void methodBoxVar(Integer in) {
         System.out.println("Integer");
     }

     static void methodBoxVar(Integer... i) {
         System.out.println("Integers");
     }
     public static void main(String[] args) {
         int intVal1 = 25;
         methodBoxVar(intVal1);
    }
}

Debe tener en cuenta lo siguiente al utilizar el embalaje automático: Como sabemos, toda característica buena tiene un inconveniente. El embalaje para automóviles no es una excepción a este respecto. Algunas notas importantes que un desarrollador debe tener en cuenta al utilizar esta función:

• Comparar objetos con el ==operador '' puede resultar confuso, ya que se puede aplicar a tipos y objetos primitivos. Cuando este operador se aplica a objetos, en realidad compara referencias a los objetos, no los objetos en sí.

Listado 7: Código de muestra que muestra la comparación.

public class Comparator {
   public static void main(String[] args) {
     Integer istInt = new Integer(1);
       Integer secondInt = new Integer(1);

       if (istInt == secondInt) {
         System.out.println("both one are equal");

       } else {
          System.out.println("Both one are not equal");
      }
   }
}

• Mezclar objetos y tipos primitivos con los operadores de igualdad y relacionales. Si comparamos un tipo primitivo con un objeto, entonces el objeto no tiene caja, lo que puede arrojar NullPointerExceptionsi el objeto null.
• Almacenamiento en caché de objetos. El método valueOf()crea un contenedor de objetos primitivos que almacena en caché. Debido a que los valores se almacenan en caché en el rango de -128 a 127, inclusive, estos objetos almacenados en caché pueden comportarse de manera diferente.
• Degradación del rendimiento. El autoboxing o unboxing degrada el rendimiento de la aplicación porque crea un objeto no deseado que obliga al recolector de basura a ejecutarse con más frecuencia.

Desventajas de AutoBoxing Aunque AutoBoxing tiene una serie de ventajas, tiene las siguientes desventajas: Listado 8: Código de muestra que muestra el problema de rendimiento.

public int sumEvenNumbers(List intList) {
          int sum = 0;
          for (Integer i : intList) {
              if (i % 2 == 0) {
                  sum += i;
              }
          }
         return sum;
   }

En esta sección de código, sum +=i se ampliará a sum = sum + i. A partir del +operador '', la JVM comienza a desempaquetar porque el +operador '' no se puede aplicar a un objeto entero. Y luego el resultado se vuelve a empaquetar automáticamente. Antes de JDK 1.5, los tipos de datos inty los enteros eran diferentes. En caso de sobrecarga de métodos, estos dos tipos se utilizaron sin problemas. Con la llegada del embalaje/desembalaje automático, esto se ha vuelto más difícil. Un ejemplo de esto es el método sobrecargado remove()en ArrayList. La clase ArrayListtiene dos métodos de eliminación: remove(index)y remove(object). En este caso, no se producirá la sobrecarga del método y se llamará al método correspondiente con los parámetros apropiados.

Conclusión

Autoboxing es un mecanismo para convertir implícitamente tipos de datos primitivos en clases contenedoras (objetos) correspondientes. El compilador utiliza el método valueOf()para convertir tipos primitivos en objetos, y los métodos IntValue(), doubleValue()etc., para obtener los tipos primitivos del objeto. El autoboxing convierte el tipo booleano booleana booleano, bytea byte, chara carácter, floata flotante, inta entero, longa largo y shorta corto. El desembalaje se realiza en sentido inverso. Artículo original