Por que método equals () quando temos o operador ==?

Quando vejo a implementação do método equals() , ela não faz nada além do que o == faz. Então, minha pergunta é qual era a necessidade de ter este método separado quando nós temos o operador == que faz o mesmo trabalho?

Você não pode sobrecarregar o operador == , mas pode sobrescrever equals(Object) se quiser que ele se comporte diferente do operador == , ou seja, não compare referências, mas compare os objects (por exemplo, usando todos ou alguns de seus campos).

Além disso, se você replace equals(Object) , dê uma olhada no hashCode() também. Estes dois methods precisam ser compatíveis (isto é, dois objects que são iguais de acordo com equals(Object) precisam ter o mesmo hashCode() ), caso contrário, todos os tipos de erros estranhos ocorrerão (por exemplo, ao adicionar objects a um conjunto ou mapa) .

== compara referências de object e pergunta se as duas referências são as mesmas.

equals() compara o conteúdo do object e pergunta se os objects representam o mesmo conceito.

No caso de primitivos , o operador == verifica se dois valores são iguais.
Se não são primitivos, ele verifica se são dois pointers (ou referências ) apontando para a mesma instância de um object.

O método equals() executa uma verificação customizada, que está em Object verificando a referência, usando == . Mas em outras classs, às vezes, equals() é substituído (não sei se isso é um particípio passado correto) . equals() tem que verificar o conteúdo .

Então, por exemplo:

 int i0 = 34; int i1 = 34; int i2 = 35; // results i0 == i1: true i1 == i0: true i2 == i0: false 

Mas se tivermos não primitivos

 String str0 = new String("Hello man!"); String str1 = new String("Hello man!"); String str2 = new String("!nam olleH"); String str2copy = str2; // Results str0 == str1: false // Pointer to two different object, so == will give false str1 == str2: false // Idem str2 == str2copy: true // So this are two pointers to the same object str0.equals(str1): true // This are not the same objects, but they are equal str1 == str1: true // Again: two times a pointer to the same object 

Então, por que str0.equals(str1) retorna true ? Porque a class String tem uma substituição de equals() . E nesse método ele não verifica se eles são iguais return this == obj; Mas nesse método, há uma verificação completa. Eu não sei qual método eles usam para comparar as duas strings, mas aqui estão duas maneiras possíveis:

  • Gerando a partir das duas cadeias um código hash e verifique se elas são iguais ( int == int )
  • Verificando caractere por caractere, se eles forem iguais.

Então, espero que isso esteja claro agora.

Existe uma diferença muito importante entre os dois.

“==” compara instâncias de object. A implementação equals () padrão também faz isso. Por favor, execute e analise o seguinte exemplo de código:

 public class Person{ String name; public Person(String name){ this.name = name; } //overriding equals public boolean equals( Object obj ) { if( this == obj ) return true; if( obj == null ) return false; if( getClass() != obj.getClass() ) return false; Person other = (Person) obj; if( name == null ) { if( other.name != null ) return false; } else if( !name.equals( other.name ) ) return false; return true; } } ... ... Person john1 = new Person("John"); Person john2 = new Person("John"); System.out.println("john1 == john2:" + (john1 == john2)); System.out.println("john1.equals(john2):" + john1.equals(john2)); 

Como você pode ver, “==” retornará false (os objects são duas instâncias diferentes de Person), enquanto equals retornará true (porque definimos que 2 Persons são iguais quando possuem o mesmo nome)

== operador é usado para comparar referências.
O método equals () é definido sobre a definição do object.

 Dog d =new Dog(); Collar c =new Collar("Red"); d.setCollar(c); Dog d2=new Dog(); Collar c2=new Collar("Red"); d2.setCollar(c2); d2.getCollar() ==d.getCollar() 

retornaria falso indicando que os dois cães têm dois objects de colarinho diferentes (itens). eles não compartilham o mesmo colarinho .

 d2.getCollar().equals(d.getCollar()) 

return true se o colarinho é definido como [o colarinho é o mesmo se a cor do colarinho é a mesma] os dois cães têm o colar da mesma cor.

  class Collar{ String color=""; public Collar(String p0){ this.color=p0; } boolean equals(Object c){ Collar other=(Collar)c; return this.color.equals(other.getColor()); } public String getColor(){ return this.color; } } 

Isso é feito para tornar isso possível:

 String s1 = new String("foo"); String s2 = new String("foo"); System.out.println(s1 == s2); // false?! Different references! System.out.println(s1.equals(s2)); // true 

Se você verificar a origem de String#equals() , verá que substituiu o Object#equals() adequadamente para comparar o array de caracteres internos um do outro (o valor real ). Muitas outras classs têm esse método substituído também.

“string” == “string” irá retornar false “string” .equals (“string”) irá retornar true

Com o1 == o2 você compara que o object 1 é o mesmo object que o2 (por referência)

Com o1.equals (o2), dependendo do object, o método equals é sobrescrito e não implementado com algo como “return o1 == o2”

Por exemplo, você cria 2 instâncias de conjunto. Esses 2 objects de conjunto são 2 objects diferentes, você pode adicionar elementos diferentes em qualquer um deles. set1 == set2 sempre retornará false mas set1.equals (set2) retornará true se o set2 contiver exatamente os mesmos elementos que set1 … e porque o método equals é sobrescrito na class Set …

A implementação igual para Set é:

  public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Set)) return false; Set s = (Set) o; if (s.size() != c.size()) return false; return containsAll(s); // Invokes safe containsAll() above } 

No operador java equals (==) opera em dados de duas variables ​​se os operandos forem de tipos de dados primitivos. Mas se os operandos são objects, java os compara usando referências, porque não tem como descobrir qual campo ou campos do object.

Portanto, há apenas uma maneira de comparar com base nos campos definidos pelo usuário e que é definida no object substituindo os methods equals (), pois o operador equals (==) não pode ser substituído no java, pois o java não suporta a substituição do operador.

Por exemplo, se você quiser comparar Employee com base no nome, é necessário definir sua lógica substituindo o método equals na class Employee conforme abaixo:

 public class Employee { private Integer id; private String name; @Override public boolean equals(Object obj) { Employee other = (Employee) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } }