Compare dois objects com o operador .equals () e ==

Eu construí uma class com um campo String . Então eu criei dois objects e tenho que compará-los usando == operator e .equals() também. Aqui está o que eu fiz:

 public class MyClass { String a; public MyClass(String ab) { a = ab; } public boolean equals(Object object2) { if(a == object2) { return true; } else return false; } public boolean equals2(Object object2) { if(a.equals(object2)) { return true; } else return false; } public static void main(String[] args) { MyClass object1 = new MyClass("test"); MyClass object2 = new MyClass("test"); object1.equals(object2); System.out.println(object1.equals(object2)); object1.equals2(object2); System.out.println(object1.equals2(object2)); } } 

Depois da compilation, mostra duas vezes falso como resultado. Por que é falso se os dois objects tiverem os mesmos campos – “teste”?

== compara referências de objects, verifica se os dois operandos apontam para o mesmo object (não objects equivalentes , o mesmo object).

Se você quiser comparar strings (para ver se elas contêm os mesmos caracteres), será necessário comparar as strings usando equals .

No seu caso, se duas instâncias do MyClass forem realmente consideradas iguais se as strings corresponderem, então:

 public boolean equals(Object object2) { return object2 instanceof MyClass && a.equals(((MyClass)object2).a); } 

… mas geralmente, se você está definindo uma class, há mais a equivalência do que a equivalência de um único campo ( a neste caso).


Nota lateral: Se você replace equals , você quase sempre precisará replace o hashCode . Como se diz no JavaDoc equals :

Observe que geralmente é necessário replace o método hashCode sempre que esse método for substituído, de modo a manter o contrato geral para o método hashCode , que declara que objects iguais devem ter códigos hash iguais.

você deve replace equals

  public boolean equals (Object obj) { if (this==obj) return true; if (this == null) return false; if (this.getClass() != obj.getClass()) return false; // Class name is Employ & have lastname Employe emp = (Employee) obj ; return this.lastname.equals(emp.getlastname()); } 

Parece que equals2 está apenas chamando equals , então isso dará os mesmos resultados.

Seu método equals2() sempre retornará o mesmo que equals() !!

Seu código com meus comentários:

 public boolean equals2(Object object2) { // equals2 method if(a.equals(object2)) { // if equals() method returns true return true; // return true } else return false; // if equals() method returns false, also return false } 

A function de substituição igual a () está errada. O object “a” é uma instância da class String e “object2” é uma instância da class MyClass . Eles são classs diferentes, então a resposta é “falsa”.

A melhor maneira de comparar dois objects é convertendo-os em strings json e comparando as strings, é a solução mais fácil ao lidar com objects nesteds, campos e / ou objects complicados que contêm matrizes.

amostra:

 import com.google.gson.Gson; Object a = // ...; Object b = //...; String objectString1 = new Gson().toJson(a); String objectString2 = new Gson().toJson(b); if(objectString1.equals(objectString2)){ //do this } 

As declarações a == object2 e a.equals(object2) retornarão sempre false porque a é uma string enquanto object2 é uma instância de MyClass

Sua implementação deve gostar:

 public boolean equals2(Object object2) { if(a.equals(object2.a)) { return true; } else return false; } 

Com esta implementação seus dois methods funcionariam.

Sua class pode implementar a interface Comparable para obter a mesma funcionalidade. Sua class deve implementar o método compareTo () declarado na interface.

 public class MyClass implements Comparable{ String a; public MyClass(String ab){ a = ab; } // returns an int not a boolean public int compareTo(MyClass someMyClass){ /* The String class implements a compareTo method, returning a 0 if the two strings are identical, instead of a boolean. Since 'a' is a string, it has the compareTo method which we call in MyClass's compareTo method. */ if(this.a.compareTo(someMyClass.a) == 0) return 0; return 1; } public static void main(String[] args){ MyClass object1 = new MyClass("test"); MyClass object2 = new MyClass("test"); if(object1.compareTo(object2) == 0){ System.out.println("true"); } else{ System.out.println("false"); } } } 

o tipo de retorno de object.equals já é booleano. não há necessidade de envolvê-lo em um método com ramificações. Então, se você quiser comparar dois objects, basta compará-los:

 boolean b = objectA.equals(objectB); 

b já é verdadeiro ou falso.

Quando usamos ==, a referência do object é comparada não aos objects reais. Precisamos replace o método equals para comparar objects Java.

Algumas informações adicionais C ++ tem operador sobre o carregamento e Java não fornece o operador sobre o carregamento. Também outras possibilidades em java são implementar Compare Interface .que define um método compareTo.

Interface de comparação também é usada comparar dois objects

O operador “==” retorna true somente se as duas referências apontarem para o mesmo object na memory. O método equals (), por outro lado, retorna true com base no conteúdo do object.

Exemplo:

 String personalLoan = new String("cheap personal loans"); String homeLoan = new String("cheap personal loans"); //since two strings are different object result should be false boolean result = personalLoan == homeLoan; System.out.println("Comparing two strings with == operator: " + result); //since strings contains same content , equals() should return true result = personalLoan.equals(homeLoan); System.out.println("Comparing two Strings with same content using equals method: " + result); homeLoan = personalLoan; //since both homeLoan and personalLoand reference variable are pointing to same object //"==" should return true result = (personalLoan == homeLoan); System.out.println("Comparing two reference pointing to same String with == operator: " + result); 

Saída: Comparando duas strings com o operador ==: false Comparando duas Strings com o mesmo conteúdo usando o método equals: true Comparando duas referências apontando para a mesma String com == operator: true

Você também pode obter mais detalhes no link: http://javarevisited.blogspot.in/2012/12/difference-between-equals-method-and-equality-operator-java.html?m=1

Aqui a saída será falsa, falsa na primeira declaração sopln você está tentando comparar um tipo de string varible do tipo Myclass com o outro tipo MyClass e ele irá permitir por causa de ambos serem do tipo Object e você ter usado o operador “==” que irá verificar o valor da variável de referência que contém a memory real e não as contagens reais dentro da memory. No segundo sopln também é o mesmo que você está chamando novamente a.equals (object2) onde a é uma variável dentro do object1. Deixe-me saber suas descobertas sobre isso.

Se você não precisar personalizar a function toString () padrão, outra maneira é sobrescrever o método toString (), que retorna todos os atributos a serem comparados. então compare a saída toString () de dois objects. Gerei o método toString () usando o IntelliJ IDEA IDE, que inclui o nome da class na string.

 public class Greeting { private String greeting; @Override public boolean equals(Object obj) { if (this == obj) return true; return this.toString().equals(obj.toString()); } @Override public String toString() { return "Greeting{" + "greeting='" + greeting + '\'' + '}'; } } 

No código abaixo você está chamando o método overriden .equals ().

public boolean equals2 (object object2) {if (a.equals (object2)) {// aqui você está chamando o método overriden, é por isso que você está obtendo false 2 vezes. retorno verdadeiro; } mais retorna falso; }

  /** Comparing two or more variables. Here the two items are compared and it will return a boolean true or false. * * @return equals */ public boolean equals(Object item) { String emp1 = this.toString(); String emp2 = item.toString(); return emp1.equals(emp2); } @Override //In case you have more than one variable. public String toString() { return a + b; } // a and b represent the variables to display.