Pessoal estou com duvida em boxing e unboxing

Para comparar objetos deve-se utilizar o equals, mesmo com o boxing não deixa de ser objetos.

System.out.println("First Style " + (b1.equals(b2))); //Line 1
 System.out.println("Second Style " + (b3.equals(b4))); // Line 2

Por que o operador de igualdade compara referências, e não valores.

Para comparar valores use o método equals()…

T+

No primeiro caso, há autoboxing, e note que “Byte b1 = 5” não é equivalente a “Byte b1 = new Byte (5)” e sim “Byte b1 = Byte.valueOf (5)”, que reaproveita um java.lang.Byte.
No segundo caso não há autoboxing e não há reaproveitamento de objetos.

class TestIntegers{
 
     public static void main(String[] args){
 
          Byte b1 = 5; // equivale a b1 = Byte.valueOf (5),
          // usando um java.lang.Byte que foi pré-criado (os valores
          // de -128 a +127 são pré-criados
          Byte b2 = 5; // equivale a b2 = Byte.valueOf (5),
          // usando um java.lang.Byte que foi pré-criado (os valores
          // de -128 a +127 são pré-criados
          Byte b3 = new Byte("10"); // aloca um completamente novo java.lang.Byte.
          // new pede explicitamente para criar algo completamente novo.
          Byte b4 = new Byte("10"); // aloca um completamente novo java.lang.Byte
          System.out.println("First Style " + (b1 == b2)); // true
          System.out.println("Second Style " + (b3 == b4)); // false
     }
}

Compilei o código aqui e vi que o resultado é:

true
false

e não

false
false

como eu esperava.

Mais uma aula do Thingol…

Thingol eu pensava que como esses wrapper tem o mesmo valor eles referenciariam o mesmo Objeto :shock: . Mas essa questão de reaproveitar Objeto você poderia me explicar melhor ???

Vamos lá.

Wrapper não tem nada de mágico; é só um objeto que encapsula (“embrulha”) um tipo primitivo.

Quando você usa “new”, sempre é criado um novo objeto - sem dó nem piedade. Sempre.

Só que quando você usa wrappers, o Java já deixa prontos 256 objetos (de -128 a +127) já “pré-alocados” para poder usar com o método valueOf. Isso vale para Integer, Short, Byte e Long. (Para Boolean ele deixa pronto Boolean.TRUE e Boolean.FALSE; e para Character ele deixa pronto de (char) 0 até (char) 127.)
Se você usar valueOf, ou então ocorrer o autoboxing (que é uma forma disfarçada de chamar valueOf), ele primeiro vê se o valor que você está pedindo está entre -128 e +127. Se estiver, ele lhe retorna um desses objetos já pré-alocados. Se não estiver, ele simplesmente chama “new”, mesmo que você já tenha usado o valor antes.

Exemplo:

Long L = Long.valueOf (12345); // usa new porque o valor é grande
Long M = Long.valueOf (12345); // usa new porque o valor é grande
System.out.println (L == M); // imprime false
L = Long.valueOf (42); // pega o pré-alocado porque o valor é pequeno
M = Long.valueOf (42); // pega o pré-alocado porque o valor é pequeno
System.out.println (L == M); // imprime true

Atenção - isso não deve cair em sua certificação. É só um detalhe de implementação.
Para comparar corretamente dois wrappers, use equals, que compara os valores, não as referências dos objetos

Pode ser que sim, mas no livro da Kathy ela fala sobre isso, segue o trecho:

It’s just two wrapper objects that happen to have the same value. Because they have the same int value, the equals() method considers them to be “meaningfully equivalent”, and therefore returns true. How about this one:

Integer i3 = 10;

Integer i4 = 10;

if(i3 == i4) System.out.println(“same object”);

if(i3.equals(i4)) System.out.println(“meaningfully equal”);

This example produces the output:

same object
meaningfully equal

Yikes! The equals() method seems to be working, but what happened with = = and != ? Why is != telling us that i1 and i2 are different objects, when = = is saying that i3 and i4 are the same object? In order to save memory, two instances of the following wrapper objects will always be = = when their primitive values are the same:

Boolean

Byte

Character from \u0000 to \u007f (7f is 127 in decimal)

Short and Integer from -128 to 127

T+