Alguém pode me explicar a diferença entre equals e == .
Estou tentando comparar datas usando Calendar.getTime().
Agradeço a ajuda.
== testa se dois objetos são idênticos. Ou seja, se ocupam o mesmo local na memória.
Equals testa conteúdo.
Você pode ter 2 strings, por exemplo, com o mesmo conteúdo, mas sendo objetos diferentes:
String a = new String(“Teste”);
String b = new String(“Teste”);
a == b; //False
a.equals(b); //True
O mesmo vale pro seu calendar.
O == só testa conteúdo no caso dos tipos primitivos.
4 curtidas
== , compara a referenção de um objeto na memória
equals compara o valor dele
Ex
Integer x = 0;
Integer y =0;
// x == y - isso retorna false, pois os OBJETOS são diferentes
//x.equals(y) - isso retorna true, pois os VALORES são iguais
1 curtida
mals ai rsrs , quando comecei a escrever ainda não tinha nenhuma resposta
1 curtida
Agora especificamente sobre o calendar.
Não há diferença entre fazer:
calendar.equals(outroCalendar);Ou:
Calendar.getTime().equals(outroCalendar.getTime());A função getTime() não retorna as horas, e sim, a data e hora, encapsulada num objeto do tipo DateTime. Se você quiser lidar só com as horas, precisará comparar campo a campo, usando o get.
Outra opção é largar essa horrível biblioteca de calendar da Oracle e usar o Joda-Time:
http://joda-time.sourceforge.net/
Valeu pela explicação, mas ainda tenho problemas.
Tenho uma classe intervalo, e estou tentando comparar dois intervalos. Intervalo tem Date inicial e Date final.
Já fiz a comparação de várias maneiras, a útlima foi essa.
public static boolean equals(Interval i1, Interval i2) {
if(i1.getStartDate().compareTo(i2.getStartDate())== 0)
if(i1.getEndDate().compareTo(i2.getEndDate())== 0){
System.out.println(“datas iguais”);
return true;
}
System.out.println(“datas diferentes”);
return false;
}
e a saída está abaixo
Sun May 01 00:00:00 BRT 2011
Wed Jun 01 00:00:00 BRT 2011
Sun May 01 00:00:00 BRT 2011
Wed Jun 01 00:00:00 BRT 2011
datas diferentes
Alguém pode me mostrar onde estou falhando?
O compare testará até os milissegundos das duas datas. Tem certeza que são idênticos?
O if pode ser simplificado para:
if (i1.getStartDate().equals(i2.getStartDate()) && i1.getEndDate().equals(i2.getEndDate())
System.out.println("Intervalos idênticos");
else
System.out.println("Intervalos diferentes");
Obrigado pela ajuda.
Resolvi o problema. Estava faltando zerar os milisegundos antes da comparação.
Valeu ViniGodoy, tinha acabado de resolver.
haha
Abraço.
resgatando o tópico: Entendi que o == compara as referências mas e no caso dos outros operadores (<=, >=, !=). Funcionam do mesmo tipo? Existe algum método para testar conteúdo quando falamos deles?
Att…
1 curtida
[quote=hcmm]resgatando o tópico: Entendi que o == compara as referências mas e no caso dos outros operadores (<=, >=, !=). Funcionam do mesmo tipo? Existe algum método para testar conteúdo quando falamos deles?
Att…[/quote]
Não. Esses operadores simplesmente não funcionam com objetos.
1 curtida
Entedi… mas, por exemplo, Caso eu queira testar se um objeto do tipo Integer é maior ou igual a outro. Como faço?
[quote=hcmm] [quote=ViniGodoy]
Não. Esses operadores simplesmente não funcionam com objetos.
[/quote]
Entedi… mas, por exemplo, Caso eu queira testar se um objeto do tipo Integer é maior ou igual a outro. Como faço?[/quote]
Você tem que chamar o método intValue(), longValue(), etc… para retornar o valor e então comparar.
As classes que são wrappers de tipos primitivos (Integer, Short, Byte, Character, Long, Double, Float e Boolean) são tratadas de maneira especial pela VM. Elas fazem o que chamamos de Auto-boxing e Unboxing. Como a VM sabe que se tratam de classes que guardam tipos primitivos, isso aqui é possível:
[code]Integer x = 10; //Equivalente a Integer x = Integer.valueOf(10);
Integer y = 20; //Equivalente a Integer x = Integer.valueOf(350);
if (x >= 5) //Equivalente a if (x.intValue() >= 5) {
System.out.println(“X é maior do que 5”);
}
[/code]
Entretanto, é preciso tomar cuidado, pois o AutoBoxing custa caro. Além disso, nem sempre o resultado é o esperado, veja:
[code]Integer x= 50;
Integer y = 50;
Integer z = 500;
Integer w = 500;
if (x == y) {
System.out.println(“X é igual a Y”);
}
if (z == w) {
System.out.println(“Z é igual a W”);
}
if (z == 500) {
System.out.println(“Z é igual a 500”);
}
if (w == 500) {
System.out.println(“W é igual a 500”);
}
[/code]
O resultado desse código é:
X é igual a Y
Z é igual a 500
W é igual a 500
Por que Z não é igual a W? A pegadinha do Mallandro é que: como no caso temos dois objetos, não é feito o auto-unboxing. Então, são comparadas as referências. Z e W são objetos diferentes na memória, por isso, o retorno false. Mas, se é assim, por que x == y?
Por que o auto-boxing tem um cache de números no intervalo -127 até 128, retornando sempre o mesmo objeto nesses casos.
Cruel, não?
2 curtidas