Equals e ==

Qual saída?

public class Tester { public static void main(String[] args) { int x = 5; Integer x1 = x; Integer x2 = x; int x3 = new Integer(5); System.out.println(x1.equals(x)); System.out.println(x1==x2); System.out.println(x2.equals(x1)); System.out.println(x2==x1); System.out.println(x2==x3);//true? System.out.println(x2.equals(x3)); } }

Qual a saída e por que a linha 11 da true? Para mim era false.

Isto se dá pois o == compara o endereço dos objetos, o HashMap dos objetos, por isso eles nao sao iguais.

Mas qdo compara com equals ele compara o conteudo de cada objeto.

Nao sei se consegui explicar. Mas acredito ser isso

Olá,

Sim é o endereço de hash… mas como está em “int”

então:

x2==x3: true

agora…

será:

x2==x3: false

Abraço!

Minha primeira resposta certa, isso q dá estudar um pouco os conceitos.

Valeu javaman00

Todas as saídas são true.

A saída da linha 11 é true porque, repare que x3 é uma variável do tipo primitivo int, portanto o que é verificado é se x2 vale 5. x2 passará pelo processo de unboxing para que esse teste possa ser realizado, o que será verificado na realidade são duas variáveis do tipo primitivo int.

Exatamente isso que o leandro falou.
o Equals compara se o valor dos dois objetos são iguais, enquanto qui o == compara se eles possuem a mesma referencia, se as variáveis forem objetos só seram true se uma estiver recebendo a outra.
Porem o == tem uma “coisinha” interessante.
Se vc comparar por exemplo:
Integer a= 127;
Integer b= 127;
System.out.println(a==b); //retornará true

Mas se vc fizer:
Integer a= 128;
Integer b= 128;
System.out.println(a==b); //retornará false

Não sei explicar ao certo, mas é por causa do tamanho do byte que só vai até o 127…
Mas na SCJP 5 não cai nada tão específico assim… Pelo menos na minha nao caiu.

[quote=gugaa_df]Exatamente isso que o leandro falou.
o Equals compara se o valor dos dois objetos são iguais, enquanto qui o == compara se eles possuem a mesma referencia, se as variáveis forem objetos só seram true se uma estiver recebendo a outra.
Porem o == tem uma “coisinha” interessante.
Se vc comparar por exemplo:
Integer a= 127;
Integer b= 127;
System.out.println(a==b); //retornará true

Mas se vc fizer:
Integer a= 128;
Integer b= 128;
System.out.println(a==b); //retornará false

Não sei explicar ao certo, mas é por causa do tamanho do byte que só vai até o 127…
Mas na SCJP 5 não cai nada tão específico assim… Pelo menos na minha nao caiu.[/quote]

Estranho! Rsss

[quote=javaman00][quote=gugaa_df]Exatamente isso que o leandro falou.
o Equals compara se o valor dos dois objetos são iguais, enquanto qui o == compara se eles possuem a mesma referencia, se as variáveis forem objetos só seram true se uma estiver recebendo a outra.
Porem o == tem uma “coisinha” interessante.
Se vc comparar por exemplo:
Integer a= 127;
Integer b= 127;
System.out.println(a==b); //retornará true

Mas se vc fizer:
Integer a= 128;
Integer b= 128;
System.out.println(a==b); //retornará false

Não sei explicar ao certo, mas é por causa do tamanho do byte que só vai até o 127…
Mas na SCJP 5 não cai nada tão específico assim… Pelo menos na minha nao caiu.[/quote]

Ah? Cara… Sinceramente, você cherou cueca? Rsss

           Integer a= 127;
           Integer b= 127;
           System.out.println(a==b); 
true

           Integer aa= 128;
           Integer bb= 128;
           System.out.println(a==b); 
true

Para de assistir o jogo dos Gambas… Porque se não vai ficar ROXO de vergonha rsss

Abraço![/quote]

ñ entendi o q vc fez ai… o q quis passa? rs:)

[quote=Rojas][quote=javaman00][quote=gugaa_df]Exatamente isso que o leandro falou.
o Equals compara se o valor dos dois objetos são iguais, enquanto qui o == compara se eles possuem a mesma referencia, se as variáveis forem objetos só seram true se uma estiver recebendo a outra.
Porem o == tem uma “coisinha” interessante.
Se vc comparar por exemplo:
Integer a= 127;
Integer b= 127;
System.out.println(a==b); //retornará true

Mas se vc fizer:
Integer a= 128;
Integer b= 128;
System.out.println(a==b); //retornará false

Não sei explicar ao certo, mas é por causa do tamanho do byte que só vai até o 127…
Mas na SCJP 5 não cai nada tão específico assim… Pelo menos na minha nao caiu.[/quote]

Ah? Cara… Sinceramente, você cherou cueca? Rsss

           Integer a= 127;
           Integer b= 127;
           System.out.println(a==b); 
true

           Integer aa= 128;
           Integer bb= 128;
           System.out.println(a==b); 
true

Para de assistir o jogo dos Gambas… Porque se não vai ficar ROXO de vergonha rsss

Abraço![/quote]

ñ entendi o q vc fez ai… o q quis passa? rs:)[/quote]

Nãooo! desconsidera! Ta certo o que o nosso amigo fez…

[quote=javaman00][quote=Rojas][quote=javaman00][quote=gugaa_df]Exatamente isso que o leandro falou.
o Equals compara se o valor dos dois objetos são iguais, enquanto qui o == compara se eles possuem a mesma referencia, se as variáveis forem objetos só seram true se uma estiver recebendo a outra.
Porem o == tem uma “coisinha” interessante.
Se vc comparar por exemplo:
Integer a= 127;
Integer b= 127;
System.out.println(a==b); //retornará true

Mas se vc fizer:
Integer a= 128;
Integer b= 128;
System.out.println(a==b); //retornará false

Não sei explicar ao certo, mas é por causa do tamanho do byte que só vai até o 127…
Mas na SCJP 5 não cai nada tão específico assim… Pelo menos na minha nao caiu.[/quote]

Ah? Cara… Sinceramente, você cherou cueca? Rsss

           Integer a= 127;
           Integer b= 127;
           System.out.println(a==b); 
true

           Integer aa= 128;
           Integer bb= 128;
           System.out.println(a==b); 
true

Para de assistir o jogo dos Gambas… Porque se não vai ficar ROXO de vergonha rsss

Abraço![/quote]

ñ entendi o q vc fez ai… o q quis passa? rs:)[/quote]

Nãooo! desconsidera! Ta certo o que o nosso amigo fez…[/quote]

toda certeza hehe :wink:

[quote=Rojas][quote=javaman00][quote=Rojas][quote=javaman00][quote=gugaa_df]Exatamente isso que o leandro falou.
o Equals compara se o valor dos dois objetos são iguais, enquanto qui o == compara se eles possuem a mesma referencia, se as variáveis forem objetos só seram true se uma estiver recebendo a outra.
Porem o == tem uma “coisinha” interessante.
Se vc comparar por exemplo:
Integer a= 127;
Integer b= 127;
System.out.println(a==b); //retornará true

Mas se vc fizer:
Integer a= 128;
Integer b= 128;
System.out.println(a==b); //retornará false

Não sei explicar ao certo, mas é por causa do tamanho do byte que só vai até o 127…
Mas na SCJP 5 não cai nada tão específico assim… Pelo menos na minha nao caiu.[/quote]

Rojas, obrigado pelo destaque demasiado no meu post errado…

Acabei ficando como a camisa dos gambas ROXO de vergonha eheheh :shock:

Ah? Cara… Sinceramente, você cherou cueca? Rsss

           Integer a= 127;
           Integer b= 127;
           System.out.println(a==b); 
true

           Integer aa= 128;
           Integer bb= 128;
           System.out.println(a==b); 
true

Para de assistir o jogo dos Gambas… Porque se não vai ficar ROXO de vergonha rsss

Abraço![/quote]

ñ entendi o q vc fez ai… o q quis passa? rs:)[/quote]

Nãooo! desconsidera! Ta certo o que o nosso amigo fez…[/quote]

toda certeza hehe ;)[/quote]

Ahh e obrigado pelo destaque demasiado, pelo meu post errado.

Sou eu que fiquei agora ROXO de vergonha, como a camisa dos gambas… :shock:

o resultado de

Integer a = 127;
Integer b = 127;
System.out.println(a==b);//true

é diferente deste

Integer a = 128;
Integer b = 128;
System.out.println(a==b);//false

Isso pq o 127 é do tamanho de um byte, enquanto q o outro numero 128 já é de tipo short, o q muda o hashmap desta variavel.

[quote=leandro.ferreira]o resultado de

Integer a = 127;
Integer b = 127;
System.out.println(a==b);//true

é diferente deste

Integer a = 128;
Integer b = 128;
System.out.println(a==b);//false

Isso pq o 127 é do tamanho de um byte, enquanto q o outro numero 128 já é de tipo short, o q muda o hashmap desta variavel.[/quote]

Sim está correto, erro meu! Em meus testes troquei as variaveis… Está absolutamente correto!

cara uma maneira fácil de você entender isso é o seguinte…

public static void main(String... rafa){

Integer a = new Integer(5);
int b = a;

System.out.println(b==a);//aqui será true..
//o importante a entender aqui é que você tem um int e um Objecto do tipo Integer, na verdade o compilador transformará esse seu código em algo parecido com o que está abaixo...
[code]
System.out.println(b==a.intValue());
[/code]
//aqui você comparará os bits do valor 5 que são 101(binário...) 


}

valew espero que tenha te ajudado !

Eu entendi a colocação de alguns mas para mim fica ainda a pergunta. x2 e x3 apontam para o mesmo local para poder retornar true?

Não. sempre que existe um boxing haverá um novo objeto, se
Integer i1 = 5; //quer dizer: Integer i1 = new Integer(5) através do boxing
Integer i2 = 10; //quer dizer: Integer i2 = new Integer(10) através do boxing

porém, para valores menores que 128(tamanho de um byte) a comparação com == retorna verdadeiro

Trecho do livro da Katherine Sierra & Bert Bates:
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

Boolean b1 = new Boolean(“true”);
Boolean b2 = new Boolean(“TRUE”);

[color=darkred]System.out.println(b1 == b2); //verdadeiro, porém são objetos diferentes![/color] Equívoco meu… SÓ FUNCIONA QUANDO TEM BOXING!

x3 é uma variável primitiva não “aponta” para nenhum objeto, o que ela armazena é o valor 5, que é igual ao valor empacotado pelo objeto da classe Wrapper Integer referenciado por x2.

[quote=paulocanedo]
Boolean b1 = new Boolean(“true”);
Boolean b2 = new Boolean(“TRUE”);

System.out.println(b1 == b2); //verdadeiro, porém são objetos diferentes![/quote]
Tem certeza que é verdadeiro, já experimentou colocar isso num IDE e ver a saída? O que está acontecendo aí é que dois objetos estão sendo instanciados e sendo atribuídos a duas variáveis distintas do tipo Boolean, e como == compara se duas referências, que obrigatoriamente tem que estar na mesma hierarquia de classes, apontam para o mesmo objeto o resultado da verificação será falso.

x3 é uma variável primitiva não “aponta” para nenhum objeto, o que ela armazena é o valor 5, que é igual ao valor empacotado pelo objeto da classe Wrapper Integer referenciado por x2.

[quote=paulocanedo]
Boolean b1 = new Boolean(“true”);
Boolean b2 = new Boolean(“TRUE”);

System.out.println(b1 == b2); //verdadeiro, porém são objetos diferentes![/quote]
Tem certeza que é verdadeiro, já experimentou colocar isso num IDE e ver a saída? O que está acontecendo aí é que dois objetos estão sendo instanciados e sendo atribuídos a duas variáveis distintas do tipo Boolean, e como == compara se duas referências, que obrigatoriamente tem que estar na mesma hierarquia de classes, apontam para o mesmo objeto o resultado da verificação será falso.[/quote]

concerteza isso oque você falo esta completamente certo objetos do tipo Wrapper do tipo Boolean são sempre iguals… quando forem feitos assim, com boxing…

Boolean a = true;
Boolean b = true;
if(a==b)//true!!!!!!!!!!

Foi mau aí cara, tava com um pouco de sono quando escrevi a mensagem, hehehe. Só funcionando quando tem boxing igual o exemplo acima do Raff

Galera brigado pela força. Enfim consegui entender e tirar minha duvida.

:wink: