Introducción a Autoboxing y Unboxing en Java
Autoboxing es la conversión automática que el compilador de Java realiza entre los tipos primitivos y sus correspondientes clases de contenedor de objetos, es decir, conversión de int a Integer, double a Double, etc. Unboxing es la conversión automática de objetos de clase de contenedor a sus primitivas equivalentes, es decir, Integer a int etc. Esta característica se introdujo en la versión 1.5 de java, autoboxing y unboxing, ya que son procesos automáticos manejados por JRE, el punto más importante aquí es escribir el código adecuado, que no agrega objetos innecesarios excesivos en la imagen.
Ahora analicemos cómo funciona el Autoboxing y Unboxing en Java internamente:
- El compilador utiliza el método valueOf () para convertir primitivas a los objetos de contenedor correspondientes (es decir, autoboxing) internamente, en el caso contrario utiliza intValue (), doubleValue (), etc., como paradigmas para unboxing.
- Como referencia, el mapeo de envolturas y primitivas en Java se menciona a continuación:
| Tipo primitivo | Clase de envoltura |
| booleano | Booleano |
| byte | Byte |
| carbonizarse | Personaje |
| flotador | Flotador |
| En t | Entero |
| largo | Largo |
| corto | Corto |
| doble | Doble |
Ejemplos -
- Tomemos una ArrayList of Integers de vez en cuando y usemos el concepto de unboxing:
import java.util.ArrayList;
public class MyClass (
public static void main(String args()) (
ArrayList intlist = new ArrayList();
//wrapper Integer objects being added here
intlist.add(1);
interest.add(2);
//auto-unboxing is happening here
int x = intlist.get(0);
System.out.println(x);
)
)
- Por lo tanto, en el ejemplo anterior, al agregar valor a x, vemos que x parece ser una primitiva, por lo que el desempaquetado ocurre aquí automáticamente mientras se realiza esta asignación.
public class MyClass (
public static void main(String args()) (
Integer sum =0;
for(int i=0;i<10;i++)
(
sum = sum + i;
)
System.out.println(sum);
)
)
- Justo arriba hemos mostrado un ejemplo -2 en este contexto, donde se ha presentado un escenario típico. Si está familiarizado con la creación de objetos en java, puede ver que "Integer sum = 0", declara un objeto, y cuando hacemos cálculos dentro del ciclo for, podemos ver que el valor primitivo "i" se agrega al contenedor " suma".
- Por lo tanto, uno puede encontrar que primero, la conversión de envoltorio a primitivo ocurrirá, ya que el operador "+" trabaja solo en primitivas, y por lo tanto, el desempaquetado de objetos ocurrirá primero, luego ocurrirá el cálculo, luego el autoboxing de objetos ocurrirá nuevamente y luego el valor será asignado a la variable "suma".
- Esto presenta una sobrecarga innecesaria en la JVM ya que se crearán muchos objetos Integer intermedios y serán destruidos (para luego ser recolectados de basura), por lo tanto, puede aparecer una desaceleración, por lo que dichas lógicas se manejarán con cuidado.
- Veamos ahora condiciones diferentes de las percepciones generales y tendremos un código en el que el autoboxing y el unboxing se vuelven muy importantes para ser entendidos.
Considere el fragmento que se encuentra debajo, ¿cuál cree que será el resultado de esto?
public class Main
(
public static void main(String() args) (
Integer m = 34123;
Integer x = 34123;
System.out.println(x==m);
)
)
- Si está diciendo "verdadero", entonces es "falso" porque la salida también es "falsa", es porque podemos comparar solo el rango entero de -128 a 127 de esta manera, para valores que salen de este rango deben ser sin caja
- Por lo tanto, necesitamos comparar intValue () de los enteros anteriores, por ahora, el compilador hace esto usando la propiedad valueOf ().
- Probablemente, si esto cae en el rango citado anteriormente, entonces el código anterior será verdadero, ya que primero se referirá al grupo literal entero para la comparación.
public class Main
(
public static void main(String() args) (
Integer m = 100;
Integer x = 100;
System.out.println(x==m);
)
)
Esto evaluará el valor "verdadero", ya que 100 está presente en el grupo literal.
Autoboxing y Unboxing en Java con sobrecarga de métodos
- Antes de etiquetar el autoboxing y el unboxing para la sobrecarga de métodos, se supone que el lector conoce el concepto de sobrecarga de métodos, solo daremos pequeñas ideas y, para obtener más información, consulte la documentación de Oracle sobre el mismo.
- La sobrecarga de métodos es un proceso en el que se usa el mismo nombre de método con un número diferente de argumentos de entrada, diferentes tipos de datos de variables con los mismos nombres, etc., se utilizan para presentar múltiples variantes de cualquier método de cálculo en general.
- Tomemos un ejemplo de lo mismo para entenderlo más profundamente y también presentaremos el resultado que aparece en la imagen esta vez:
public class Main
(
public static void main(String() args) (
Overload obj = new Overload();
int i =5;
obj.printval(5);
Integer m = i;
obj.printval(m);
)
)
class Overload
(
public void printval(int i)
(
System.out.println("printing the unboxed value "+ i);
)
public void printval(Integer i)
(
System.out.println("printing the autoboxed value "+ i);
)
)
Salida -
imprimir el valor sin caja 5
imprimir el valor de autoboxed 5
Nota: puede ejecutar el programa anterior en cualquiera de los IDE para obtener el resultado colocado anteriormente.
- Por lo tanto, el comportamiento anterior indica claramente que la técnica de autoboxing tiene un uso significativo en los conceptos de sobrecarga y debe usarse con cuidado durante la codificación.
Ventajas de Autoboxing y Unboxing en Java-
- La conversión adecuada se realiza automáticamente por el compilador.
- Se supone que el desarrollador debe escribir un código menor y, por lo tanto, un código más limpio.
- No hay necesidad de expresiones manuales de conversión de tipos.
Conclusión
Vimos el caso de uso de autoboxing y unboxing, cuán implícito es este concepto y dónde puede crear ventajas y desventajas. Debe usarse con cuidado al codificar, de lo contrario puede sumar gastos generales innecesarios de conversión computacional, por lo tanto, las conversiones se realizarán en las primitivas para evitar una carga excesiva de recolección de basura y una creación excesiva de objetos temporales. También vimos el caso de uso de autoboxing con el concepto de sobrecarga de java, puede verificar algunas restricciones más junto con esto.
Artículos recomendados
Esta ha sido una guía para Autoboxing y Unboxing en Java. Aquí también discutimos ¿Qué es Autoboxing y Unboxing en java? ¿Cómo funciona internamente con algunos códigos de muestra? También puede consultar nuestros otros artículos sugeridos para obtener más información:
- ¿Qué es el JDBC?
- ¿Qué es genéricos en Java?
- Groovy vs Java
- ¿Qué es la herencia de Java?
- Ejemplos y cómo funcionan los genéricos en C #
- JRE vs JVM | Las 8 principales diferencias con (infografía)