Este é um novo conteúdo introduzido após o jdk1.5. Como insisto que publicar é a melhor memória, decidi substituir minha memória por um blog:
A especificação da linguagem Java diz: Em muitos casos, o empacotamento e a descompactação são feitos pelo próprio compilador (nesse caso, o empacotamento é chamado de boxing e o desempacotamento é chamado de unboxing);
Na verdade, de acordo com meu próprio entendimento, o boxe automático pode ser simplesmente entendido como o encapsulamento de tipos de dados básicos em tipos de objetos para cumprir a orientação a objetos do Java, por exemplo, use int como exemplo:
Copie o código do código da seguinte forma:
//Declara um objeto inteiro
Número inteiro = 10;
//A instrução acima usa boxe automático: analisada como
Integer num = new Integer(10); O exemplo acima é um bom exemplo, porque 10 pertence ao tipo de dados básico, em princípio, não pode ser atribuído diretamente a um objeto Integer, mas depois de jdk1.5 você pode fazer esta instrução, esta. é o charme do autoboxing para converter automaticamente tipos de dados básicos em tipos encapsulados correspondentes. Depois de se tornar um objeto, você pode chamar todos os métodos declarados pelo objeto para desempacotá-lo automaticamente: daí o nome, significa reconverter o objeto em um tipo de dados básico:
//boxe
Número inteiro = 10;
//desembalar
int num1 = num; Um uso muito típico de unboxing automático é ao realizar operações: porque os objetos não são operados diretamente, mas devem ser convertidos em tipos de dados básicos antes que a adição, subtração, multiplicação e divisão possam ser realizadas.
Número inteiro = 10;
// O unboxing automático está implícito ao realizar cálculos
System.out.print(num--); Haha, deve parecer muito simples. Agora vou falar sobre algo um pouco mais difícil.
//Números fora de -128~127
Número inteiro1 = 297; Número inteiro2 = 297;
System.out.println("num1==num2: "+(num1==num2));
// Número entre -128~127
Número inteiro3 = 97; Número inteiro4 = 97;
System.out.println("num3==num4: "+(num3==num4)); O resultado impresso é: num1==num2: false num3==num4: true
É estranho: isso se deve ao design Java de boxe e unboxing automático de Integer e int. É um modo: chamado modo flyweight (flyweight).
Para aumentar a reutilização de números simples, Java define: Durante o boxe automático, para valores entre 128 e 127, após serem encaixotados em objetos Inteiros, eles serão armazenados na memória para reutilização, e sempre haverá apenas um objeto E se exceder o valor entre 128 e 127, o Inte em caixa. O objeto ger não será reutilizado, o que equivale a criar um novo objeto Integer toda vez que for encaixotado, entenda, o fenômeno acima é causado pelo uso do boxe automático, mas siga as classes gerais. , se você usar new para instanciar, um novo objeto será criado toda vez que new for usado;
Este boxe e unboxing automático não é usado apenas em tipos de dados básicos, mas também na classe String. Por exemplo, quando declaramos frequentemente um objeto String:
Copie o código do código da seguinte forma:
String str = "sl";
//Substitua o seguinte método de declaração
String str = new String("sl");
Autoboxing e unboxing de tipos de dados básicos (primitivos) são funções fornecidas desde J2SE 5.0. Embora forneça conveniência para empacotar tipos de dados básicos, ele também oculta os detalhes. É recomendado usá-lo somente quando você puder distinguir a diferença entre tipos de dados básicos e objetos.
autoboxing e unboxing
Em Java, quase tudo a ser processado é um objeto (Object). Por exemplo, o Scanner usado antes é um objeto, e a String (String) também é um objeto. No entanto, os tipos de dados básicos não são objetos, ou seja, variáveis que você define usando int, double, boolean, etc., e constantes literais que você escreve diretamente.
Na seção anterior, vimos aproximadamente a conveniência de operar objetos, e qualquer pessoa que já usa Java há algum tempo sabe que às vezes é necessário converter tipos de dados básicos em objetos. Por exemplo, ao usar o método put() de um objeto Map, os parâmetros que precisam ser passados são objetos em vez de tipos de dados básicos.
Você precisa usar tipos de wrapper (tipos de wrapper) para agrupar tipos de dados básicos em objetos. Na seção anterior, você já sabe que antes do J2SE 5.0, você precisa usar a seguinte instrução para agrupar int em um objeto Integer: Integer integer = new. Inteiro(10) ;
A função de boxing automático é fornecida após o J2SE 5.0. Você pode usar diretamente a seguinte instrução para empacotar tipos de dados básicos: Integer integer = 10;
Ao compilar, o compilador determinará automaticamente se deve executar o boxe automático com base nas instruções que você escreveu. No exemplo acima, inteiro refere-se a uma instância da classe Integer. A mesma ação pode ser aplicada a tipos de dados básicos, como boolean, byte, short, char, long, float, double, etc. Os tipos de wrapper correspondentes (Wrapper Types) Boolean, Byte, Short, Character, Long, Float ou Double serão ser usado respectivamente. Vamos usar diretamente a função autoboxing para reescrever o Exemplo 4.4.
Exemplo 4.5 AutoBoxDemo.java
Copie o código do código da seguinte forma:
classe pública AutoBoxDemo {
public static void main(String[] args) {
Dados inteiros1 = 10;
Dados inteiros2 = 20;
// Converte para valor duplo e divide por 3
System.out.println(data1.doubleValue()/3);
//Compara dois valores
System.out.println(dados1.compareTo(dados2));
}
}
O programa parece muito mais simples. data1 e data2 são instâncias de Integer em tempo de execução e podem executar operações de objeto diretamente. O resultado é o seguinte:
3.3333333333333335
1
O método de utilização do boxe automático também pode ser o seguinte:
Copie o código do código da seguinte forma:
int eu = 10;
Inteiro inteiro = i;
Você também pode usar a classe java.lang.Number mais geral para autoboxing. Por exemplo:
Número numérico = 3,14f;
3.14f será automaticamente encaixotado como Float e então atribuído ao número.
A partir do J2SE 5.0, o boxing automático e o unboxing automático estão disponíveis, ou seja, as informações básicas do formulário de dados no objeto são automaticamente retiradas do objeto. Por exemplo, é possível escrever o seguinte:
Copie o código do código da seguinte forma:
Inteiro fooInteger = 10;
int fooPrimitivo = fooInteger;
Depois que fooInteger for referenciado a uma instância que é automaticamente encaixotada como Integer, se for atribuído a uma variável fooPrimitive do tipo int, ela será automaticamente alterada para o tipo int e, em seguida, atribuída a fooPrimitive. Durante a operação, o encaixotamento e desembalagem automáticos também podem ser realizados. Por exemplo:
Copie o código do código da seguinte forma:
Inteiro i = 10;
System.out.println(i + 10);
System.out.println(i++);
No exemplo acima, 20 e 10 serão exibidos. O compilador executará automaticamente o boxe e o unboxing, ou seja, 10 será encaixotado primeiro e, em seguida, descompactado primeiro quando i + 10, e a operação de adição será executada; A linha também será encaixotada primeiro e, em seguida, executará a operação de incremento. Vejamos outro exemplo:
Copie o código do código da seguinte forma:
Booleano boo = verdadeiro;
System.out.println(boo && falso);
O mesmo boo é originalmente uma instância de Boolean. Ao executar uma operação AND, boo será descompactado primeiro e, em seguida, será aplicado AND com falso, e o resultado será exibido como falso.
/////////////////////////////////////////////// /// ////////////////
Boxing: A conversão de um tipo básico para um tipo Object é chamada de boxing; Esta operação é comumente usada no processo de reflexão.
Packing: Crie uma instância de Object no heap e copie o valor que você especificar ***Unboxing: Determine se a informação no heap apontada pela referência é do tipo a ser dividida, pegue o valor do heap e envie; para a variável da pilha, caso contrário, uma exceção será relatada
/////////////////////////////////////////////// /// /////////////////
Boxe é uma conversão eremita de um tipo de valor em um tipo de objeto ou em qualquer tipo de interface que o tipo de valor implemente.
O boxe de um tipo de valor aloca uma instância de objeto e copia o valor em um novo objeto.
Copie o código do código da seguinte forma:
int i=123;
objeto o = eu;
O resultado desta frase é criar um objeto o na pilha, que faz referência a um valor do tipo int na pilha. Este valor é atribuído à variável i
Uma cópia do valor do tipo de valor.
Abaixo está um display que realiza a conversão do boxe
Copie o código do código da seguinte forma:
int i=123;
objeto o=(objeto)i;
Este exemplo converte a variável inteira i no objeto o por meio de boxe. Desta forma, o valor armazenado na variável i muda de 123 para 456. Este exemplo mostra que o objeto mantém uma cópia original do conteúdo. Isso é 123.
Unboxing é uma conversão explícita de um tipo de objeto para um tipo de valor ou de um tipo de interface para um tipo de valor que implementa a interface. As operações de desembalagem incluem:
Verifica a instância do objeto para garantir que seja um valor em caixa do tipo de valor fornecido.
Copia o valor da instância em uma variável de tipo de valor.
exemplo:
Copie o código do código da seguinte forma:
int i=123;
caixa de objeto=i;
int j=(int)caixa;
