Este es un contenido nuevo introducido después de jdk1.5. Como insisto en que publicar es el mejor recuerdo, decidí reemplazar mi recuerdo con un blog:
La especificación del lenguaje Java dice: En muchos casos, el empaquetado y desempaquetado lo realiza el propio compilador (en este caso, el empaquetado se llama boxing y el desempaquetado se llama unboxing);
De hecho, según mi propio entendimiento, el boxeo automático puede entenderse simplemente como encapsular tipos de datos básicos en tipos de objetos para cumplir con la orientación a objetos de Java, por ejemplo, use int como ejemplo:
Copie el código de código de la siguiente manera:
//Declarar un objeto entero
Número entero = 10;
// La declaración anterior utiliza boxeo automático: analizado como
Integer num = new Integer(10); Lo anterior es un buen ejemplo, porque 10 pertenece al tipo de datos básico, en principio no se puede asignar directamente a un objeto Integer, pero después de jdk1.5 puedes hacer esta Declaración, esto. Es el encanto del autoboxing convertir automáticamente tipos de datos básicos en los tipos encapsulados correspondientes. Después de convertirse en un objeto, puede llamar a todos los métodos declarados por el objeto para desempaquetarlo automáticamente: de ahí el nombre, significa volver a convertir el objeto en un tipo de datos básico:
//boxeo
Número entero = 10;
//desembalaje
int num1 = num; Un uso muy típico del unboxing automático es al realizar operaciones: porque los objetos no se operan directamente, sino que deben convertirse en tipos de datos básicos antes de poder realizar sumas, restas, multiplicaciones y divisiones.
Número entero = 10;
// El unboxing automático está implícito al realizar cálculos
System.out.print(num--); Jaja, debería parecer muy simple. Ahora hablaré de algo un poco más difícil.
//Números fuera de -128~127
Número entero1 = 297; Número entero2 = 297;
System.out.println("num1==num2: "+(num1==num2));
// Número dentro de -128~127
Número entero3 = 97; Número entero4 = 97;
System.out.println("num3==num4: "+(num3==num4)); El resultado impreso es: num1==num2: false num3==num4: true
Es extraño: esto se debe al diseño de Java de boxing y unboxing automático de Integer e int. Es un modo: llamado modo flyweight (peso mosca).
Para aumentar la reutilización de números simples, Java define: durante el boxeo automático, para los valores entre 128 y 127, después de encuadrarlos en objetos enteros, se almacenarán en la memoria para su reutilización y siempre habrá solo uno. objeto Y si excede el valor entre 128 y 127, el Inte encajonado. El objeto ger no se reutilizará, lo que equivale a crear un nuevo objeto Integer cada vez que se encuadre; comprenda que el fenómeno anterior se debe al uso del boxeo automático, pero sigue las clases generales. , si usa new para crear una instancia, se creará un nuevo objeto cada vez que se use new;
Este boxing y unboxing automático no solo se usa en tipos de datos básicos, sino también en la clase String. Por ejemplo, cuando a menudo declaramos un objeto String:
Copie el código de código de la siguiente manera:
Cadena cadena = "sl";
//Reemplazar el siguiente método de declaración
Cadena cadena = nueva cadena ("sl");
El autoboxing y unboxing de tipos de datos básicos (Primitive) son funciones proporcionadas desde J2SE 5.0. Aunque le resulta conveniente empaquetar tipos de datos básicos, también oculta los detalles. Se recomienda utilizarlo solo cuando pueda distinguir la diferencia entre tipos de datos básicos y objetos.
autoboxing y unboxing
En Java, casi todo lo que se va a procesar es un objeto (Objeto). Por ejemplo, el Escáner utilizado antes es un objeto y la Cadena (Cadena) también es un objeto. Veremos más objetos más adelante. Sin embargo, los tipos de datos básicos no son objetos, es decir, variables que usted define usando int, double, boolean, etc., y constantes literales que escribe directamente.
En la sección anterior, hemos visto a grandes rasgos la conveniencia de operar objetos, y cualquiera que haya usado Java por un tiempo sabe que a veces es necesario convertir tipos de datos básicos en objetos. Por ejemplo, cuando se utiliza el método put() de un objeto Map, los parámetros que se deben pasar son objetos en lugar de tipos de datos básicos.
Necesita usar tipos de contenedor (Tipos de contenedor) para envolver tipos de datos básicos en objetos. En la sección anterior, ya sabía que antes de J2SE 5.0, necesitaba usar la siguiente declaración para envolver int en un objeto Integer: Integer integer = new. Entero(10);
La función de empaquetado automático se proporciona después de J2SE 5.0. Puede utilizar directamente la siguiente declaración para empaquetar tipos de datos básicos: Integer integer = 10;
Al compilar, el compilador determinará automáticamente si debe realizar un boxeo automático en función de las declaraciones que escribió. En el ejemplo anterior, un número entero se refiere a una instancia de la clase Integer. La misma acción se puede aplicar a tipos de datos básicos como booleano, byte, corto, char, largo, flotante, doble, etc. Los tipos de contenedor correspondientes (tipos de contenedor) booleano, byte, corto, carácter, largo, flotante o doble utilizarse respectivamente. Usemos directamente la función autoboxing para reescribir el Ejemplo 4.4.
Ejemplo 4.5 AutoBoxDemo.java
Copie el código de código de la siguiente manera:
clase pública AutoBoxDemo {
público estático vacío principal (String [] argumentos) {
Datos enteros1 = 10;
Datos enteros2 = 20;
//Convertir a valor doble y dividir por 3
System.out.println(data1.doubleValue() / 3);
//Compara dos valores
System.out.println(datos1.compareTo(datos2));
}
}
El programa parece mucho más simple. data1 y data2 son instancias de Integer en tiempo de ejecución y pueden realizar operaciones de objetos directamente. El resultado es el siguiente:
3.3333333333333335
1
El método de utilización del boxeo automático también puede ser el siguiente:
Copie el código de código de la siguiente manera:
int yo = 10;
Entero entero = i;
También puede utilizar la clase java.lang.Number más general para el autoboxing. Por ejemplo:
Número número = 3.14f;
3.14f se encuadrará automáticamente como Flotante y luego se asignará a un número.
A partir de J2SE 5.0, el boxeo automático y el unboxing automático están disponibles, es decir, la información básica del formulario de datos en el objeto se extrae automáticamente del objeto. Por ejemplo, es posible escribir lo siguiente:
Copie el código de código de la siguiente manera:
Entero fooInteger = 10;
int fooPrimitivo = fooInteger;
Después de que se hace referencia a fooInteger a una instancia que se encuadra automáticamente como Integer, si se asigna a una variable fooPrimitive de tipo int, se cambiará automáticamente al tipo int y luego se asignará a fooPrimitive. Durante el funcionamiento, también se puede realizar el empaquetado y desembalaje automático. Por ejemplo:
Copie el código de código de la siguiente manera:
Entero i = 10;
System.out.println(i + 10);
System.out.println(i++);
En el ejemplo anterior, se mostrarán 20 y 10. El compilador realizará automáticamente el boxeo y el desempaquetado, es decir, 10 se encuadrará primero y luego se desempaquetará primero cuando i + 10, y se realizará la operación de suma; La línea también se encuadrará primero. Desempaque y luego realice la operación de incremento. Veamos otro ejemplo:
Copie el código de código de la siguiente manera:
Booleano = verdadero;
System.out.println(boo && falso);
El mismo boo es originalmente una instancia de booleano. Al realizar una operación AND, boo se desempaquetará primero y luego se aplicará AND con falso, y el resultado mostrará falso.
////////////////////////////////////////////////// /// //////////////////
Boxeo: la conversión de un tipo básico a un tipo de objeto se llama boxeo. ***Unboxing: la operación de conversión de un objeto a un tipo básico se llama unboxing. Esta operación se utiliza comúnmente en el proceso de reflexión.
Embalaje: cree una instancia de Objeto en el montón y copie el valor que especifique *** Unboxing: determine si la información en el montón señalada por la referencia es del tipo que se va a dividir, tome el valor del montón y envíelo; a la variable de pila; de lo contrario, se informará una excepción
////////////////////////////////////////////////// /// ///////////////////
El boxeo es una conversión ermitaña de un tipo de valor a un tipo de objeto o a cualquier tipo de interfaz que implemente el tipo de valor.
Al encuadrar un tipo de valor se asigna una instancia de objeto y se copia el valor en un nuevo objeto.
Copie el código de código de la siguiente manera:
intyo=123;
objeto o=i;
El resultado de esta oración es crear un objeto o en la pila, que hace referencia a un valor de tipo int en el montón. Este valor se asigna a la variable i.
Una copia del valor del tipo de valor.
A continuación se muestra una pantalla que realiza la conversión de boxeo.
Copie el código de código de la siguiente manera:
intyo=123;
objeto o=(objeto)i;
Este ejemplo convierte la variable entera i en el objeto o mediante boxeo. De esta forma, el valor almacenado en la variable i cambia de 123 a 456. Este ejemplo muestra que el objeto conserva una copia original del contenido. Eso es 123.
Unboxing es una conversión explícita de un tipo de objeto a un tipo de valor o de un tipo de interfaz a un tipo de valor que implementa la interfaz. Las operaciones de desempaquetado incluyen:
Comprueba la instancia del objeto para asegurarse de que sea un valor encuadrado del tipo de valor dado.
Copia el valor de la instancia en una variable de tipo de valor.
ejemplo:
Copie el código de código de la siguiente manera:
intyo=123;
cuadro de objeto = i;
int j=(int)caja;
