Wrappers, AutoBoxing e Unboxing

Autoboxing/Unboxing (um recurso novo da linguagem) usa os Wrappers (recurso antigo da linguagem). De fato, são dois lados da mesma coisa.

Autoboxing e autounboxing é o uso automático dos wrappers.

Basicamente o compilador transforma isso:Integer i = 2; int j = i; Nisso:Integer i = Integer.valueOf(2); // Boxing int j = i.intValue(); // Unboxing.

No java 1.4 e inferiores, o boxing e unboxing tinha que ser feito manualmente. No java 5 e superiores, o compilador faz para você.

Autoboxing é quando um objeto representa um tipo primitivo.
Unboxing é quando tipos primitivos representam objetos.

Um exemplo de autoboxing:

int n;
// ...
Integer i = n;  // *

Você pega o valor do primitivo e coloca ele em um objeto.

Exemplo de unboxing:

Integer n;
// ...
int i = n; // *

• • É necessário ressaltar que fazer isso diretamente só veio depois do Java 5.

Algumas referências:
Autoboxing e Unboxing: http://java.sun.com/j2se/1.5.0/docs/guide/language/autoboxing.html
http://www.guj.com.br/posts/reply/0/103298.java

Você pode notar que são coisas inversas (auto = int para Integer. un = Integer para int.).

Wrapper você pode ver aqui: http://www.guj.com.br/posts/list/56737.java , no post do ViniGodoy.

[editado]Opz, mesma hora. Sorry.[/editado]

Jaba:

Boa Tarde Pessoal, Fmz?

Bom, procurei aqui no forum e não encontrei nenhum tópico que realmente discutisse isso de verdade, então:

Qual é a real diferença entre Wrappers e AutoBoxing/Unboxing?

Me desculpem a ignorância se eu estiver errado, mas, no contexto que me foi explicado, pareceu a mesma coisa!

Wrapper é uma designação genérica para todo o objeto que encapsula outro. Em particular é uma designação para
as classes do java que encapsulam os tipos primitivos ou seja (Integer, Double, Character, Short, etc…)

O Integer por exemplo é um objeto que contém um int lá dentro. O Integer atua como uma caixa ( box) para o int lá dentro.
Se vc quiser criar uma lista de int vc não consegue porque List só permite conter objetos e int não é um objeto. Então os wrappers servem para usar os primitivos como objetos sempre que isso é necessário ( como colocar numa lista , por exemplo).
Mas para ler o valor vc precisa invocar intValue() no Integer para que o int seja retornado.
Antigamente vc escrevia isto:

List lista = new ArrayList();

lista.add(new Integer(2)); // encaixota o 2 no wrapper para usa como objeto

Integer integer = (Integer)lista.get(0);

int dois = integer.intValue(); // des-encaixota o 2 de dentro do wrapper para usar como primitivo.

O Java 1.5 trouxe o conceito de Tipo Genérico e com ele o conceito de Auto-boxing (auto-encaixotamento)
e a operação inversa ( Auto-unboxing, auto-desencaixotamento).

List<Integer> lista = new ArrayList<Integer>();

lista.add(2); // encaixota o 2 no wrapper _automaticamente_ para usa como objeto

int dois = lista.get(0);  // des-encaixota o 2 de dentro do wrapper  _automaticamente_ para usar como primitivo.

Veja como o código é bastante simplificado.

Wrapper são as classes respectivas à cada um dos dos 8 tipos de dados primitivos. Pode se dizer que são a versão objeto desses tipos.

Boxing é o ato de colocar um tipo primitivo em um objeto, e com o Autoboxing do Java 5, você pode tratar esses objetos wrapper e seus respectivos primitivos da mesma forma sem precisar de códigos especiais.

Po, Galera, valew pela Boa Vontade!!!

Bom, resumindo o que eu entendi e vocês confirmam:

As Classes Encapsuladoras de Tipos de Dados Primitivos são chamadas de Wrappers.
O processo de Encapsular um Tipo Primitivo em um Objeto é chamado de AutoBoxing.
O processo de Desencapsular um Objeto em um tipo Primitivo é chamado de UnBoxing.

Wrappers:

Integer Character Short Boolean Float Double Byte Long

AutoBoxing:

int i = 5; Integer usuarioJabaGostoso = i;

UnBoxing:

int i; i = (int)usuarioJabaGostoso;

Bruno Laturner:

Wrapper são as classes respectivas à cada um dos dos 8 tipos de dados primitivos. Pode se dizer que são a versão objeto desses tipos.

Boxing é o ato de colocar um tipo primitivo em um objeto, e com o Autoboxing do Java 5, você pode tratar esses objetos wrapper e seus respectivos primitivos da mesma forma sem precisar de códigos especiais.

Só complementando, java.lang.Void é o wrapper de void. Embora pareça que isso não faz muito sentido, ele é necessário para dar suporte a mecanismos de reflection.

valeu a dica

Eu tenho uma dúvida:

Double d = 2.2;
double e = 2.2;

System.out.println(d.equals(e)?"Iguais":"Diferentes"); //(1)
System.out.println(d == e)?"Iguais":"Diferentes"); //(2)

O autoboxing apenas faz automaticamente algo que faríamos na mão (Double d = new Double(e), p. exemplo). Se eu comparar d e e [(1) e (2)], porque retorna true? d é um objeto e e é um tipo primitivo.