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.
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]
[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]
[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]
[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]
[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:
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...)
}
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!!!!!!!!!!