Java.lang.object tem dois métodos muito importantes definidos: public boolean equals (Object obj) e public int hashCode().

método equals()

Em java, o método equals() é usado para comparar a igualdade de dois objetos. A igualdade pode ser comparada de duas maneiras:

• Comparação superficial: A implementação padrão do método equals é definida na classe Java.lang.Object, que simplesmente verifica se duas referências de objeto (digamos xey) se referem ao mesmo objeto. ou seja, verifica se x == y. Como a classe Object não tem membros de dados que definam seu estado, ela também é conhecida como comparação superficial.
• Comparação profunda: suponha que uma classe forneça sua própria implementação do método equals() para comparar os objetos dessa classe em relação ao estado dos objetos. Isso significa que os membros de dados (ou seja, campos) de objetos devem ser comparados uns com os outros. Essa comparação com base em membros de dados é conhecida como comparação profunda.

Sintaxe:

public boolean equals  (Object obj)

// This method checks if some other Object
// passed to it as an argument is equal to 
// the Object on which it is invoked.

Alguns princípios do método equals() da classe Object: Se algum outro objeto é igual a um determinado objeto, ele segue estas regras:

• Reflexivo: para qualquer valor de referência a, a.equals (a) deve retornar verdadeiro.
• Simétrico: para quaisquer valores de referência a e b, se a.equals (b) retornar verdadeiro, então b.equals (a) deve retornar verdadeiro.
• Transitivo: para quaisquer valores de referência a, b e c, se a.equals (b) retornar verdadeiro e b.equals (c) retornar verdadeiro, então a.equals (c) deve retornar verdadeiro.
• Consistente: para quaisquer valores de referência a e b, várias invocações de a.equals (b) retornam consistentemente verdadeiro ou consistentemente retornam falso, desde que nenhuma informação usada em comparações de igual no objeto seja modificada.

  Observação: para qualquer valor de referência não nulo a, a.equals (nulo) deve retornar falso.

// Java program to illustrate 
// how hashCode() and equals() methods work
import java.io.*;
  
class Geek 
{
      
    public String name;
    public int id;
          
    Geek(String name, int id) 
    {
              
        this.name = name;
        this.id = id;
    }
      
    @Override
    public boolean equals(Object obj)
    {
          
    // checking if both the object references are 
    // referring to the same object.
    if(this == obj)
            return true;
          
        // it checks if the argument is of the 
        // type Geek by comparing the classes 
        // of the passed argument and this object.
        // if(!(obj instanceof Geek)) return false; ---> avoid.
        if(obj == null || obj.getClass()!= this.getClass())
            return false;
          
        // type casting of the argument. 
        Geek geek = (Geek) obj;
          
        // comparing the state of argument with 
        // the state of 'this' Object.
        return (geek.name == this.name && geek.id == this.id);
    }
      
    @Override
    public int hashCode()
    {
          
        // We are returning the Geek_id 
        // as a hashcode value.
        // we can also return some 
        // other calculated value or may
        // be memory address of the 
        // Object on which it is invoked. 
        // it depends on how you implement 
        // hashCode() method.
        return this.id;
    }
      
}
  
//Driver code
class GFG
{
      
    public static void main (String[] args)
    {
      
        // creating the Objects of Geek class.
        Geek g1 = new Geek("aa", 1);
        Geek g2 = new Geek("aa", 1);
          
        // comparing above created Objects.
        if(g1.hashCode() == g2.hashCode())
        {
  
            if(g1.equals(g2))
                System.out.println("Both Objects are equal. ");
            else
                System.out.println("Both Objects are not equal. ");
      
        }
        else
        System.out.println("Both Objects are not equal. "); 
    } 
}

Saída:

Both Objects are equal.

No exemplo acima, veja a linha:

// if(!(obj instanceof Geek)) return false;--> avoid.-->(a)

Usamos esta linha em vez da linha acima:

if(obj == null || obj.getClass()!= this.getClass()) return false; --->(y)

Aqui, primeiro estamos comparando o hashCode em ambos os objetos (ou seja, g1 e g2) e se o mesmo hashcode é gerado por ambos os objetos, isso não significa que eles são iguais, pois o hashcode pode ser o mesmo para objetos diferentes também, se eles tiverem o mesmo id (neste caso). Portanto, se get os valores do hashcode gerados são iguais para ambos os objetos, depois comparamos esses dois objetos em relação ao seu estado para que substituamos o método equals (Object) dentro da classe. E se ambos os objetos têm o mesmo estado de acordo com o método equals (Object), então eles são iguais, caso contrário, não. E seria melhor desempenho do que se objetos diferentes gerassem valores de hashcode diferentes.

Motivo: a referência obj também pode se referir ao objeto da subclasse de Geek. A linha (b) garante que retornará falso se o argumento passado for um objeto da subclasse da classe Geek. Mas a condição do operador instanceof não retorna false se descobrir que o argumento passado é uma subclasse da classe Geek. Leia o operador InstanceOf .

método hashCode()

Ele retorna o valor do hashcode como um inteiro. O valor do Hashcode é usado principalmente em coleções baseadas em hash, como HashMap, HashSet, HashTable… .etc. Este método deve ser sobrescrito em todas as classes que sobrescrevem o método equals().
Sintaxe:

public int hashCode()

// This method returns the hash code value 
// for the object on which this method is invoked.

O contrato geral de hashCode é:

• Durante a execução do aplicativo, se hashCode() for chamado mais de uma vez no mesmo objeto, ele deve retornar consistentemente o mesmo valor Integer, desde que nenhuma informação usada na comparação de equals (Object) no objeto seja modificada. Não é necessário que este valor inteiro permaneça o mesmo de uma execução da aplicação para outra execução da mesma aplicação.
• Se dois objetos são iguais, de acordo com o método equals (Object) , então o método hashCode() deve produzir o mesmo inteiro em cada um dos dois objetos.
• Se dois Objetos forem desiguais, de acordo com o método equals (Object) , não é necessário que o valor Integer produzido pelo método hashCode() em cada um dos dois Objetos seja distinto. Pode ser o mesmo, mas produzir o Inteiro distinto em cada um dos dois Objetos é melhor para melhorar o desempenho de Coleções baseadas em hash como HashMap, HashTable ... etc.

Nota: Objetos iguais devem produzir o mesmo código hash, desde que sejam iguais; no entanto, objetos desiguais não precisam produzir códigos hash distintos.

Link relacionado: Substituindo igual em
Referência Java : JavaRanch

Este artigo é uma contribuição de Nitsdheerendra . Se você gosta de GeeksforGeeks e gostaria de contribuir, você também pode escrever um artigo usando contribute.geeksforgeeks.org ou enviar o seu artigo para contribute@geeksforgeeks.org. Veja o seu artigo na página principal do GeeksforGeeks e ajude outros Geeks.

Escreva comentários se encontrar algo incorreto ou se quiser compartilhar mais informações sobre o tópico discutido acima.