Galera até 127 os Wrappers não retornam true com == ???
Porque as duas primeiras comparações resultam em false ?!
public class MyClass {
public Integer startingI;
public void methodA() {
Integer i = new Integer(25);
startingI = i;
methodB(i);
}
private void methodB(Integer i2) {
i2 = i2.intValue();
System.out.println(i2 == startingI); // false. pq? o valor é 25
System.out.println(i2 == startingI); // false. pq? o valor é 25
System.out.println(i2.equals(startingI));
System.out.println(i2.equals(startingI));
}
public static void main(String[] args) {
MyClass m = new MyClass();
m.methodA();
}
}
Sei que não referênciam objetos iguals, porém não tem o esquema de funfar com == até 127 ?!
Grato
[quote=Gustavo Santos]Galera até 127 os Wrappers não retornam true com == ???
Porque as duas primeiras comparações resultam em false ?!
public class MyClass {
public Integer startingI;
public void methodA() {
Integer i = new Integer(25);
startingI = i;
methodB(i);
}
private void methodB(Integer i2) {
i2 = i2.intValue();
System.out.println(i2 == startingI); // false. pq? o valor é 25
System.out.println(i2 == startingI); // false. pq? o valor é 25
System.out.println(i2.equals(startingI));
System.out.println(i2.equals(startingI));
}
public static void main(String[] args) {
MyClass m = new MyClass();
m.methodA();
}
}
Sei que não referênciam objetos iguals, porém não tem o esquema de funfar com == até 127 ?!
Grato[/quote]
O que acontece é porque quando vc cria um Integer com um valor literal esse valor e alocado em um cache
Integer a = 10 // ocorre new Integer(10) implicitamente como o valor é menor que 128, esse objeto é alocado em uma especie de pool;
Integer b = a;
b = b.intValue(); // aqui entao e feito unboxing e em seguida boxing, a JVM verifica se tem algum objeto em cache que bata com o objeto a ser criado, como o objeto que foi alocado no cache realmente bateu com o que esta sendo feito o boxing agora, então vai ser retirado o mesmo objeto do cache e atribuido á b novamente.
Agora nesse caso e criado um objeto diretamente no heap por isso retorna false seu ==, independentemente do valor ser 127.
Integer a = new Integer(10); // objeto direto no heap.
Integer b = a; // ok referenciam o mesmo objeto no heap.
b = b.intValue(); // agora aqui esta o misterio rsrs, ou seja como nao existe nenhum objeto alocado no cache, vai ocorrer, unboxing em seguida vai ser criado um novo objeto com o boxing, chamando o new Integer(10) por nao existir nenhum objeto no cache, é o que acontece no seu exemplo, ok?.
Dei umas editadas no post, para um melhor entendimento 
Vamos lá, esses wrappers me deixam loco !!
quando eu faço algo assim é diferente ?
Integer i = 10; // esse valor vai para um poll ?? que poll ?
Integer i2 = new Integer(10); // esse objeto vai pra heap!
Cara, o que acontece aqui:
Integer i = 10;
Integer i2 = new Integer(10); // esse vai pro Heap
int i3 = 10;
int i4 = new Integer(10);
int i5 = i2.intValue();
System.out.println(i == i2); // false
System.out.println(i2 == i3); // true
System.out.println(i3 == i4); // true
System.out.println(i == i5); // true
System.out.println(i5 == i2); // true
Quando o == vai funcionar ?!
Quando eu tenho que me atentar ao valor 127?
Quando me atentar ao padrão de bits da variável de referência ?
Esse wrapper me dexam LOCOO !
È tranquilo veja só:
Voce faz:
[code]Integer numero = 10; // o new Integer(10), ocorre implicitamente, mas como vc criou de forma literal é armazenado esse “new Integer(10)” em um cache.
Integer numero2 = numero.intValue() // é feito unboxing em seguida boxing, mas como ja existe o objeto “new Integer(10)” guardado em cache, numero2 recebe o mesmo objeto que numero, por isso “==” entre os dois vai dar true. [/code]
[code]Integer numero = new Integer(10) // o objeto foi criado diretamente no heap, pq vc nao criou de forma literal, entao nao existe nada em cache.
Integer numero2 = numero.intValue() // A JVM vai primeiro no cache pra saber se existe algum objeto “new Integer(10)” que ela possa buscar e atribuir á referencia para á variavel “numero2”. Como nao existe nada no cache devido a sua variavel “numero” esta referenciando algo no heap, numero2 vai receber implicitamente um outro objeto “new Integer(10)” que sera alocado no heap. Logo se vc fizer “numero == numero2” como são dois objetos diferentes alocados em lugares diferentes no heap vai dar “false”.[/code]
Meu Brother evertonsilvagomesjava
Só me responde uma coisa - isso funciona do mesmo jeito que para
String. Quero dizer o pool String ?
Grato, sua explicação já ajudou bastante.
[quote=Gustavo Santos]Meu Brother evertonsilvagomesjava
Só me responde uma coisa - isso funciona do mesmo jeito que para
String. Quero dizer o pool String ?
Grato, sua explicação já ajudou bastante.[/quote]
Isso mesmo cara, ia ate citar o exemplo de Strings literais serem armazenadas no pool de Strings, é a mesma coisa.
evertonsilvagomesjava tu tá foda em maxo !!!
tá sabido hehehe !!
Brigadão pela força !!!