Dúvida Wrappers

Programação Java
#1

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

#2

[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?.

#3

Dei umas editadas no post, para um melhor entendimento :smiley:

#4

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 !

#5

È 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]

#6

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.

#7

[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.

#8

evertonsilvagomesjava tu tá foda em maxo !!!

tá sabido hehehe !!

Brigadão pela força !!!

#9