Pourquoi faire j'ai besoin de remplacer la equals et hashCode méthodes en Java?

Collections telles que HashMap et HashSet utiliser un hashcode valeur d'un objet afin de déterminer comment il doit être entreposé à l'intérieur d'une collection, et la hashcode est de nouveau utilisé pour localiser l'objet
dans sa collection.

De hachage de récupération est un processus en deux étapes:

1. Trouver le bon seau (à l'aide de hashCode())
2. Recherche le seau pour le droit élément (à l'aide de equals() )

Voici un petit exemple de raisons pour lesquelles nous devrions overrride equals() et hashcode().

Envisager une Employee classe qui a deux champs: l'âge et le nom.

public class Employee {

    String name;
    int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this)
            return true;
        if (!(obj instanceof Employee))
            return false;
        Employee employee = (Employee) obj;
        return employee.getAge() == this.getAge()
                && employee.getName() == this.getName();
    }

    //commented    
    /*  @Override
        public int hashCode() {
            int result=17;
            result=31*result+age;
            result=31*result+(name!=null ? name.hashCode():0);
            return result;
        }
     */
}

Maintenant créer une classe, insérer Employee objet dans un HashSet et de tester si l'objet est présent ou pas.

public class ClientTest {
    public static void main(String[] args) {
        Employee employee = new Employee("rajeev", 24);
        Employee employee1 = new Employee("rajeev", 25);
        Employee employee2 = new Employee("rajeev", 24);

        HashSet<Employee> employees = new HashSet<Employee>();
        employees.add(employee);
        System.out.println(employees.contains(employee2));
        System.out.println("employee.hashCode():  " + employee.hashCode()
        + "  employee2.hashCode():" + employee2.hashCode());
    }
}

Il permet d'imprimer les éléments suivants:

false
employee.hashCode():  321755204  employee2.hashCode():375890482

Maintenant décommentez hashcode() méthode , exécuter la même et le résultat serait:

true
employee.hashCode():  -938387308  employee2.hashCode():-938387308

Maintenant, pouvez-vous voir pourquoi, si deux objets sont égaux, leurs hashcodes doivent
également être égaux? Sinon, vous ne seriez jamais capable de trouver l'objet dans la mesure où la valeur par défaut
hashcode méthode dans la classe de l'Objet pratiquement toujours avec un numéro unique
pour chaque objet, même si le equals() méthode est substituée une manière telle que les deux
objets ou plus sont considérées comme égales. Il n'a pas d'importance comment égale les objets sont si
leur hashcodes ne reflètent pas que. Donc, une fois de plus: Si deux objets sont égaux, leur
hashcodes doivent être identiques.

Tout simplement, l'égalité de la méthode dans l'Objet de vérifier la référence de l'égalité, où deux instances de votre classe pourrait encore être sémantiquement équivalents lorsque les propriétés sont égaux. C'est par exemple important lors de la mise de vos objets dans un récipient qui utilise equals et hashcode, comme HashMap et Ensemble. Disons que nous avons une classe comme:

public class Foo {
    String id;
    String whatevs;

    Foo(String id, String whatevs) {
        this.id = id;
        this.whatevs = whatevs;
    }
}

Nous devons créer deux instances de la même id:

Foo a = new Foo("id", "something");
Foo b = new Foo("id", "something else");

Sans écraser égal à égal, nous obtenons:

• un.est égal à(b) est faux car ils sont deux instances différentes
• un.est égal à(a) est vrai car c'est la même instance
• b.est égal à(b) est vrai car c'est la même instance

Correct? Eh bien peut-être, si c'est ce que vous voulez. Mais disons que nous voulons objets avec le même id pour le même objet, qu'il s'agisse de deux instances différentes. Nous remplacer la equals (et hashcode):

public class Foo {
    String id;
    String whatevs;

    Foo(String id, String whatevs) {
        this.id = id;
        this.whatevs = whatevs;
    }

    @Override
    public boolean equals(Object other) {
        if (other instanceof Foo) {
            return ((Foo)other).id.equals(this.id);   
        }
    }

    @Override
    public int hashCode() {
        return this.id.hashCode();
    }
}

Que pour la mise en œuvre de equals et hashcode je peux vous recommandons d'utiliser Goyave l'aide de méthodes

Ok, Laissez-moi vous expliquer le concept dans des mots très simples.

Tout d'abord dans une perspective plus large, nous avons des collections,et hashmap est l'un des discbased dans les collections.

Pour comprendre pourquoi, nous devons remplacer les deux equals et hashcode méthode, si besoin en premier lieu de comprendre qu'est-ce que hashmap et ce qui est fait.

Une table de hachage est une discbased qui stocke des paires clé-valeur de données dans la matrice de la mode. Disons une[], dans laquelle chaque élément 'a' est une valeur clé de la paire.

Également chaque indice dans le tableau ci-dessus peuvent être liés liste et ainsi avoir plus d'une valeurs de l'indice.

Maintenant, pourquoi est une table de hachage utilisé?
Si nous avons à chercher parmi un large éventail ensuite la recherche par le biais de chaque si eux ne sera pas efficace, donc ce hachage technique nous dit qui vous permet de pré processus de la matrice avec un peu de logique et de regrouper les éléments basés sur la logique, c'est à dire de Hachage

par exemple: nous avons de la matrice de 1,2,3,4,5,6,7,8,9,10,11 et on applique une fonction de hachage mod 10 1,11 seront regroupés ensemble. Donc, si nous avons dû chercher pour 11 dans le tableau précédent nous aurions alors l'itération à l'ensemble de la gamme, mais quand nous sommes en groupe, il nous limitons notre champ d'itération améliorant ainsi la vitesse. Que discbased permet de stocker toutes les informations ci-dessus peut être considéré comme un tableau 2d pour des raisons de simplicité

Maintenant, mis à part la table de hachage dit aussi qu'il l'habitude d'ajouter de tout Doublons. Et c'est la principale raison pour laquelle nous devons remplacer la equals et hashcode

Alors, quand sa dit que d'expliquer le fonctionnement interne de table de hachage , nous avons besoin de trouver quelles sont les méthodes de la table de hachage est et comment faut-il suivre les règles ci-dessus lequel je l'ai expliqué ci-dessus

si la table de hachage a la méthode appelée à mettre(K,V) , et selon hashmap il devrait suivre les règles ci-dessus de manière efficace la distribution de la matrice et de ne pas ajouter tous les doublons

si ce n'est qu'il sera tout d'abord générer le hashcode de la clé donnée à décider lequel l'indice de la valeur devrait aller.si rien n'est présent à l'index alors la nouvelle valeur sera ajoutée au-dessus de là, si quelque chose est déjà présente là-bas puis la nouvelle valeur doit être ajoutée après la fin de la liste liée à l'index. mais n'oubliez pas que les doublons doivent être ajoutés par le comportement souhaité de la table de hachage. donc, disons que vous avez deux Entiers objets aa=11,b=11.
comme tous les objets dérivés de la classe de l'objet, la valeur par défaut de mise en œuvre pour la comparaison de deux objets, c'est qu'il compare la référence et non pas les valeurs à l'intérieur de l'objet. Ainsi, dans le cas ci-dessus, tant bien que sémantiquement l'égalité va échouer le test d'égalité, et de la possibilité que les deux objets qui même hashcode et les mêmes valeurs existe ainsi de créer des doublons. Si nous remplacer, puis nous avons pu éviter l'ajout de doublons.
Vous pouvez aussi consulter Détail de travail

import java.util.HashMap;
public class Employee {
String name;
String mobile;
public Employee(String name,String mobile) {
this.name=name;
this.mobile=mobile;
}
@Override
public int hashCode() {
System.out.println("calling hascode method of Employee");
String str=this.name;
Integer sum=0;
for(int i=0;i<str.length();i++){
sum=sum+str.charAt(i);
}
return sum;
}
@Override
public boolean equals(Object obj) {
//TODO Auto-generated method stub
System.out.println("calling equals method of Employee");
Employee emp=(Employee)obj;
if(this.mobile.equalsIgnoreCase(emp.mobile)){
System.out.println("returning true");
return true;
}else{
System.out.println("returning false");
return false;
}
}
public static void main(String[] args) {
//TODO Auto-generated method stub
Employee emp=new Employee("abc", "hhh");
Employee emp2=new Employee("abc", "hhh");
HashMap<Employee, Employee> h=new HashMap<>();
//for (int i=0;i<5;i++){
h.put(emp, emp);
h.put(emp2, emp2);
//}
System.out.println("----------------");
System.out.println("size of hashmap: "+h.size());
}
}

Java met une règle qui

"Si deux objets sont égaux à l'aide de la classe d'Objet est égale à la méthode, alors la méthode hashcode devrait donner la même valeur pour ces deux objets."

Donc, si dans notre classe, nous allons remplacer equals() nous devrions remplacer hashcode() méthode à suivre cette règle.
Les deux méthodes, equals() et hashcode(), sont utilisés dans Hashtable, par exemple, pour stocker des valeurs sous forme de paires clé-valeur. Si nous remplacer l'un et pas l'autre, il y a une possibilité que le Hashtable peut ne fonctionne pas comme nous le voulons, si nous utilisons un objet comme une touche.

Afin d'utiliser notre propre classe des objets comme des clés dans des collections comme la table de hachage, Hashtable, etc.. , nous devons remplacer les deux méthodes ( hashCode() et equals() ) par la présence d'une prise de conscience sur le travail interne de la collecte. Sinon, elle conduit à de mauvais résultats dont nous ne sommes pas attendus.

class A {
int i;
//Hashing Algorithm
if even number return 0 else return 1
//Equals Algorithm,
if i = this.i return true else false
}

• put('key','valeur') va calculer la valeur de hachage à l'aide de hashCode() pour déterminer la
  seau et utilise equals() méthode pour rechercher si la valeur est déjà
  présent dans le Seau. Si non, il sera ajouté sinon, il sera remplacé par la valeur courante
• get('key') va utiliser hashCode() pour trouver l'Entrée (seau) en premier et
  equals() pour trouver la valeur en Entrée

si les Deux sont remplacées,

Map<Un>

Map.Entry 1 --> 1,3,5,...
Map.Entry 2 --> 2,4,6,...

si equals n'est pas substituée

Map<Un>

Map.Entry 1 --> 1,3,5,...,1,3,5,... //Duplicate values as equals not overridden
Map.Entry 2 --> 2,4,6,...,2,4,..

Si hashCode n'est pas substituée

Map<Un>

Map.Entry 1 --> 1
Map.Entry 2 --> 2
Map.Entry 3 --> 3
Map.Entry 4 --> 1
Map.Entry 5 --> 2
Map.Entry 6 --> 3 //Same values are Stored in different hasCodes violates Contract 1
So on...

HashCode L'Égalité De Contrat

1. Deux clés de l'égalité selon l'égalité méthode doit générer le même hashCode
2. Deux Clés générant même hashCode n'a pas besoin d'être égal (Dans l'exemple ci-dessus tous les même numéros de générer le même Code de hachage)

J'étais à la recherche dans l'explication " Si vous remplacez uniquement hashCode puis quand vous appelez myMap.put(first,someValue) il prend tout d'abord, calcule son hashCode et les stocke dans un seau. Ensuite, lorsque vous appelez myMap.put(first,someOtherValue) il doit remplacer la première avec la seconde que par la Carte de la Documentation parce qu'ils sont égaux (selon notre définition)." :

Je pense que la 2ème fois, lorsque nous ajoutons dans myMap ensuite, il devrait être le "second" de l'objet comme myMap.put(second,someOtherValue)

Il est utile lors de l'utilisation de Objets de Valeur. Ce qui suit est un extrait de l' Portland Pattern Repository:

Exemples d'objets de valeur sont des choses
comme les nombres, les dates, les montants et
les chaînes de caractères. Généralement, ils sont petits
les objets qui sont utilisés très largement.
Leur identité est basée sur leur état
plutôt que sur leur identité de l'objet.
De cette façon, vous pouvez avoir plusieurs copies
de la même valeur conceptuelle de l'objet.

Afin que je puisse avoir plusieurs copies d'un
objet qui représente la date 16 Jan
1998. L'un de ces exemplaires sera égale les unes des autres. Pour un petit
l'objet de ce type, il est souvent
plus facile d'en créer de nouveaux et de les déplacer
autour plutôt que de compter sur un
objet unique pour représenter la date.

Un objet de valeur doit toujours l'emporter
.equals() en Java (ou = en Smalltalk).
(N'oubliez pas de remplacer .hashCode() en tant que
bien.)

Les méthodes equals et hashcode sont définies dans la classe de l'objet. Par défaut, si la méthode equals retourne true, alors le système va aller plus loin et vérifier la valeur de code de hachage. Si le code de hachage de l'2 objets est également de même que les objets seront considérés comme identiques. Donc, si vous remplacez seulement la méthode equals, alors même si le substituée méthode equals indique 2 objets à l'égalité , le système défini hashcode peut ne pas indiquer que les 2 objets sont égaux. Nous avons donc besoin de remplacer le code de hachage ainsi.

Dans l'exemple ci-dessous, si vous commentez la substitution est égal ou hashcode dans la classe Personne, ce code ne parviennent pas à chercher Tom de la commande. À l'aide de la valeur par défaut de mise en œuvre de hashcode peut provoquer des échecs dans la table de hachage des recherches.

Ce que j'ai ci-dessous est un code simplifié qui tire vers le haut les gens de la commande par Personne. Personne est en train d'être utilisé comme une clé dans la table de hachage.

public class Person {
String name;
int age;
String socialSecurityNumber;
public Person(String name, int age, String socialSecurityNumber) {
this.name = name;
this.age = age;
this.socialSecurityNumber = socialSecurityNumber;
}
@Override
public boolean equals(Object p) {
//Person is same if social security number is same
if ((p instanceof Person) && this.socialSecurityNumber.equals(((Person) p).socialSecurityNumber)) {
return true;
} else {
return false;
}
}
@Override
public int hashCode() {        //I am using a hashing function in String.java instead of writing my own.
return socialSecurityNumber.hashCode();
}
}
public class Order {
String[]  items;
public void insertOrder(String[]  items)
{
this.items=items;
}
}
import java.util.Hashtable;
public class Main {
public static void main(String[] args) {
Person p1=new Person("Tom",32,"548-56-4412");
Person p2=new Person("Jerry",60,"456-74-4125");
Person p3=new Person("Sherry",38,"418-55-1235");
Order order1=new Order();
order1.insertOrder(new String[]{"mouse","car charger"});
Order order2=new Order();
order2.insertOrder(new String[]{"Multi vitamin"});
Order order3=new Order();
order3.insertOrder(new String[]{"handbag", "iPod"});
Hashtable<Person,Order> hashtable=new Hashtable<Person,Order>();
hashtable.put(p1,order1);
hashtable.put(p2,order2);
hashtable.put(p3,order3);
//The line below will fail if Person class does not override hashCode()
Order tomOrder= hashtable.get(new Person("Tom", 32, "548-56-4412"));
for(String item:tomOrder.items)
{
System.out.println(item);
}
}
}

hashCode() méthode est utilisée pour obtenir un entier unique pour un objet donné. Cet entier est utilisé pour déterminer le seau emplacement, lorsque cet objet doit être stockée dans certains HashTable, HashMap comme structure de données. Par défaut, l'Objet hashCode() méthode retourne et représentation entière de l'adresse mémoire où l'objet est stocké.

La hashCode() méthode des objets est utilisée lorsque nous insérer dans un HashTable, HashMap ou HashSet. Plus sur HashTables sur Wikipedia.org pour référence.

Pour insérer une entrée dans la carte de structure de données, nous avons besoin à la fois d'une clé et une valeur. Si les deux clés et les valeurs sont de l'utilisateur de définir des types de données, la hashCode() de la clé sera de déterminer où le stockage de l'objet interne. Lors de l'exiger pour la recherche de l'objet à partir de la carte, le code de hachage de la clé sera de déterminer le lieu de la recherche de l'objet.

Le code de hachage seuls points à une certaine "zone" (ou d'une liste, seau, etc) en interne. Depuis les différents objets clés pourrait avoir le même code de hachage, le code de hachage lui-même n'est pas une garantie que la touche de droite est trouvé. Le HashTable puis itère ce domaine (toutes les touches avec le même code de hachage) et utilise la clé du equals() méthode pour trouver la bonne clé. Une fois que la clé est trouvée, l'objet stocké pour que la clé est retourné.

Donc, comme nous pouvons le voir, une combinaison de la hashCode() et equals() méthodes sont utilisées lors du stockage et lors de la recherche d'objets dans un HashTable.

NOTES:

1. Toujours utiliser les mêmes attributs d'un objet pour générer hashCode() et equals() à la fois. Comme dans notre cas, nous avons utilisé l'id de l'employé.

2. equals() doit être cohérente (si les objets ne sont pas modifiées, alors elle doit retourner la même valeur).

3. Chaque fois que a.equals(b), puis a.hashCode() doit être la même que b.hashCode().

4. Si vous remplacez un, alors vous devez remplacer l'autre.

http://parameshk.blogspot.in/2014/10/examples-of-comparable-comporator.html

Pour vous aider à vérifier pour dupliquer des Objets, nous avons besoin d'un custom equals et hashCode.

Depuis hashcode retourne toujours un certain nombre de ses toujours rapide pour récupérer un objet à l'aide d'un numéro plutôt que par une touche alphabétique. Comment faut-il faire? Supposons que nous avons créé un nouvel objet par le passage d'une certaine valeur qui est déjà disponible dans un autre objet. Maintenant, le nouvel objet sera de retour la même valeur de hachage, comme d'un autre objet, car la valeur passée est la même. Une fois la même valeur de hachage est retourné, la JVM va aller à la même adresse mémoire à chaque fois et si dans le cas où il y a plus que les objets présents pour la même valeur de hachage, il va utiliser la méthode equals() pour identifier l'objet correct.

public class Employee {
private int empId;
private String empName;
public Employee(int empId, String empName) {
super();
this.empId = empId;
this.empName = empName;
}
public int getEmpId() {
return empId;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
@Override
public String toString() {
return "Employee [empId=" + empId + ", empName=" + empName + "]";
}
@Override
public int hashCode() {
return empId + empName.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(this instanceof Employee)) {
return false;
}
Employee emp = (Employee) obj;
return this.getEmpId() == emp.getEmpId() && this.getEmpName().equals(emp.getEmpName());
}
}

De La Classe De Test

public class Test {
public static void main(String[] args) {
Employee emp1 = new Employee(101,"Manash");
Employee emp2 = new Employee(101,"Manash");
Employee emp3 = new Employee(103,"Ranjan");
System.out.println(emp1.hashCode());
System.out.println(emp2.hashCode());
System.out.println(emp1.equals(emp2));
System.out.println(emp1.equals(emp3));
}
}

Dans la Classe d'Objet equals(Object obj) est utilisé pour comparer l'adresse comparesion c'est pourquoi, lorsque dans la classe de Test, si vous comparez les deux objets, puis méthode equals donner de faux, mais quand on remplacer hashcode() que l'on peut comparer le contenu et donner un bon résultat.

Bah - "il est nécessaire de redéfinir hashCode() dans chaque classe qui remplace equals()."

[Efficaces Java, par Joshua Bloch?]

N'est-ce pas dans le mauvais sens? Primordial hashCode probablement suppose que vous écrivez un mot-clé de la classe, mais impérieuse d'égal à égal n'est certainement pas. Il y a beaucoup de classes qui ne sont pas utilisés en tant que mot-clés, mais ne voulez une logique de l'égalité-méthode d'essai pour une autre raison. Si vous choisissez "équivaut à" pour cela, vous pouvez alors être mandaté pour écrire un hashCode de la mise en œuvre par les excès de zèle de l'application de cette règle. Tout ce qui est fait est l'ajout du code non testé dans la base de code, un mal d'attente pour faire trébucher quelqu'un dans le futur. Aussi l'écriture de code, vous n'avez pas besoin d'anti-agile. Il est tout simplement faux (et un ide généré sera probablement incompatible avec votre main est égal).

Sûrement, ils devraient avoir mandaté une Interface sur des objets écrits pour être utilisés comme clés? Peu importe, l'Objet ne doit jamais avoir par défaut fourni par hashCode() et equals() à mon humble avis. Il est surement encouragé de nombreux cassé hachage collections.

Mais de toute façon, je pense que la "règle" est écrit de l'arrière vers l'avant. En attendant, je vais continuer à éviter l'utilisation des "égaux" pour l'égalité des méthodes d'essai 🙁