devstory

Comprendre Java System.identityHashCode, Object.hashCode et Object.equals

View more Tutorials:

1- Le contrat equals()

La méthode equals(Object) est utilisée pour comparer l'objet actuel avec un autre objet en fonction des valeurs des propriétés de chaque objet. Vous pouvez remplacer cette méthode dans votre classe.
public boolean equals(Object other)
Par exemple: La classe Money avec deux priopriétés: currencyCode & amount (Code de devise et de montant). Deux objets Money sont considérés comme égaux par la méthode equals() s'ils ont les mêmes currencyCode et amount:
Money.java
package org.o7planning.equals.ex;

import java.util.Objects;

public class Money {
    private String currencyCode;
    private int amount;

    public Money(String currencyCode, int amount) {
        this.amount = amount;
        this.currencyCode = currencyCode;
    }

    public int getAmount() {
        return amount;
    }

    public String getCurrencyCode() {
        return currencyCode;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Money)) {
            return false;
        }
        Money o = (Money) other;
        return this.amount == o.amount //
                && Objects.equals(this.currencyCode, o.currencyCode);
    }
}
Lorsque vous remplacez (override) la méthode equals(), vous devez respecter les critères suivants, ils sont appelés un contrat equals():
1Reflexive
(Réflexif)
Un objet doit s'égaler.
2Symmetric
(Symétrique)
x.equals(y) doit renvoyer le même résultat que y.equals(x).
3Transitive
(Transitif)
Si x.equals(y) et y.equals(z) donc x.equals(z).
4Consistent
(Cohérent)
La valeur de x.equals(y) ne change pas si les propriétés impliquées dans la comparaison ne changent pas (Le hasard n'est pas autorisé)

Symmetric

La symétrie (symmetric) de equals() doit être garantie, autrement dit, si x.equals(y) alors y.equals(x). Cela paraît être simple, mais parfois vous le violez involontairement.
Par exemple: La classe WrongVoucher ci-dessous viole la symétrie du contrat equals():
WrongVoucher.java
package org.o7planning.equals.ex;

import java.util.Objects;

public class WrongVoucher extends Money {
    private String store;

    public WrongVoucher(String store, String currencyCode, int amount) {
        super(currencyCode, amount);
        this.store = store;
    }

    public String getStore() {
        return store;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof WrongVoucher)) {
            return false;
        }
        WrongVoucher o = (WrongVoucher) other;
        
        return this.getAmount() == o.getAmount() //
                && Objects.equals(this.getCurrencyCode(), o.getCurrencyCode()) //
                && Objects.equals(this.store, o.store);
    }
}
À première vue, la classe WrongVoucher et sa méthode equals() semblent correctes. Cela fonctionne parfaitement si vous comparez 2 objets WrongVoucher, mais vous verrez des problèmes si vous comparez l'objet WrongVoucher avec l'objet Money et vice versa.
WrongVoucherTest.java
package org.o7planning.equals.ex;

public class WrongVoucherTest {
    
    public static void main(String[] args)  {
        Money m = new Money("USD", 100);
        WrongVoucher wv = new WrongVoucher("Chicago S1", "USD", 100);
        
        System.out.println("m.equals(wv): " + m.equals(wv)); // true
        System.out.println("wv.equals(m): " + wv.equals(m)); // false
    }
}
Output:
m.equals(wv): true
wv.equals(m): false
Pour éviter le piège ci-dessus, on peut réécrire la classe Voucher et utiliser Money comme propriété plutôt que d'hériter de Money.
Voucher.java
package org.o7planning.equals.ex;

import java.util.Objects;

public class Voucher {
    private String store;
    private Money money;

    public Voucher(String store, String currencyCode, int amount) {
        this.store = store;
        this.money = new Money(currencyCode, amount);
    }

    public String getStore() {
        return store;
    }

    public Money getMoney() {
        return money;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Voucher)) {
            return false;
        }
        Voucher o = (Voucher) other;
        
        return Objects.equals(this.store, o.store) //
                && this.money.equals(o.money);
    }
}

2- System.identityHashCode(Object)

Dans Java, la méthode statique System.identityHashCode(obj) renvoie identity hashcode (le code de hachage d'identité) de l'objet obj, c'est un entier non négatif compris entre [0, 2^31-1]. Identity hashcode d'un objet null est 0.
@HotSpotIntrinsicCandidate
public static native int identityHashCode(Object x);
Conformément à l'idée de conception, identity hashcode de différents objets doit être différent. Cependant ceci n'est pas absolument garanti. L'algorithme de JVM peut garantir seulement que la probabilité de identity hashcode dupliqué est très faible. Le hashcode d'identité d'un objet n'est calculé qu'au premier moment où il est réellement utilisé et stocké dans Header de l'objet.
Identity hashcode n'est certainement pas généré en fonction de l'adresse de l'objet en mémoire. Malheureusement, il n'existe aucune documentation sur l'algorithme de génération de hashcode d'identité, le secret réside dans le code source de JVM écrit en langage C++. Je mettrai à jour cet algorithme si plus d'informations sont disponibles.

3- Object.hashcode()

La méthode hashCode() de la classe java.lang.Object renvoie le hashcode de l'objet actuel, qui est exactement identity hashcode de cet objet.
public class Object  {
    
    public int hashCode() {
        return System.identityHashCode(this);
    }
}
Exemple de hashcode et identity hashcode d'un objet pur (new java.lang.Object()).
HashCodeEx1.java
package org.o7planning.hashcode.ex;

public class HashCodeEx1 {

    public static void main(String[] args) {
        Object obj1 = new Object();
        
        int idHashcode = System.identityHashCode(obj1);
        int hashcode = obj1.hashCode();
        
        System.out.println("Identity Hashcode: " + idHashcode);
        System.out.println("Hashcode: " + hashcode);
    }
}
Output:
Identity Hashcode: 1651191114
Hashcode: 1651191114
Les classes descendantes de java.lang.Object peuvent remplacer (override) la méthode hashCode() pour renvoyer une valeur personnalisée mais doivent respecter les règles suivantes, également appelées le contrat hashCode().
1Equals consistency
(La cohérence égale)
Si deux objets sont égaux selon la méthode equals(Object), leur méthode hashCode() doit renvoyer la même valeur.
2Internal consistency
(La cohérence interne)
La valeur de hashCode() ne peut changer que si les propriétés participant à la méthode equals(Object) changent.
Deux objets qui ne sont pas égaux selon la méthode equals(Object) n'ont pas nécessairement de(s) hashcodes(s) différent(s). Cependant, deux objets différents avec des valeurs de hashcode différentes amélioreront les performances de la Hash table (voir plus d'explications dans l'article sur HashMap et HashSet).
Voir plus:
  • TODO Link?
HashCodeEx2.java
package org.o7planning.hashcode.ex;

public class HashCodeEx2 {

    public static void main(String[] args) {
        Employee tom = new Employee("Tom");
        Employee jerry = new Employee("Jerry");
        
        System.out.println("Employee: " + tom.getFullName());
        System.out.println("  - Identity hashcode: " + System.identityHashCode(tom));
        System.out.println("  - Hashcode: " + tom.hashCode());
        
        System.out.println("\nEmployee: " + jerry.getFullName());
        System.out.println("  - Identity hashcode: " + System.identityHashCode(jerry));
        System.out.println("  - Hashcode: " + jerry.hashCode());
    }
}

class Employee {
    private String fullName;

    public Employee(String fullName) {
        this.fullName = fullName;
    }
    
    public String getFullName()  {
        return this.fullName;    
    }

    @Override
    public int hashCode() {
        if (this.fullName == null || this.fullName.isEmpty()) {
            return 0;
        }
        char ch = this.fullName.charAt(0);
        return (int) ch;
    }
}
Output:
Employee: Tom
  - Identity hashcode: 1579572132
  - Hashcode: 84

Employee: Jerry
  - Identity hashcode: 359023572
  - Hashcode: 74

4- La violation contre la cohérence de hashCode() & equals()

En règle générale, lorsque votre classe remplace la méthode equals(Object), vous devez également remplacer la méthode hashCode() pour vous assurer que 2 objets égaux par la méthode equals(Object) auront le même hashcode. Ceci est nécessaire et sûr lorsque vous utilisez l'objet de cette classe comme clé de *HashMap (HashMap, WeakHashMap, IdentityHashMap,...).
La classe BadTeam ci-dessous viole Equals consistency (la cohérence égale):
BadTeam.java
package org.o7planning.equals.ex;

import java.util.Objects;

public class BadTeam {
    private String name;
    private int numberOfMembers;
    
    public BadTeam(String name, int numberOfMembers) {
        this.name = name;
        this.numberOfMembers = numberOfMembers;
    }
    public String getName() {
        return name;
    }
    public int getNumberOfMembers() {
        return numberOfMembers;
    }
    
    @Override
    public boolean equals(Object other)  {
        if(this == other)  {
            return true;
        }
        if(!(other instanceof BadTeam))  {
            return false;
        }
        BadTeam o = (BadTeam) other;
        return Objects.equals(this.name, o.name);
    }
    
    @Override
    public int hashCode()  {
        return this.numberOfMembers;
    }
}
BadTeamTest.java
package org.o7planning.equals.ex;

public class BadTeamTest {

    public static void main(String[] args) {
        BadTeam team1 = new BadTeam("Team 1", 3);
        BadTeam team2 = new BadTeam("Team 1", 5);
        
        boolean isEquals = team1.equals(team2); // true
        
        int hashcode1 = team1.hashCode(); // 3
        int hashcode2 = team2.hashCode(); // 5
        
        System.out.println("team1.equals(team2): " + isEquals); // true
        System.out.println("hashcode1 == hashcode2: " + (hashcode1 == hashcode2)); // false
    }
}
Output:
team1.equals(team2): true
hashcode1 == hashcode2: false
Une violation du contrat hashCode() peut survenir lorsque vous utilisez la classe *HashMap (HashMap, WeakHashMap, IdentityHashMap,..). Les choses peuvent ne pas fonctionner comme prévu.
HashMap_BadTeam_Test.java
package org.o7planning.equals.ex;

import java.util.HashMap;

public class HashMap_BadTeam_Test {

    public static void main(String[] args) {

        // BadTeam team --> String leader.
        HashMap<BadTeam, String> map = new HashMap<>();

        BadTeam team1 = new BadTeam("Team 1", 3);
        BadTeam team2 = new BadTeam("Team 1", 5);
        
        map.put(team1, "Tom");
        map.put(team2, "Jerry");
        
        BadTeam team = new BadTeam("Team 1", 10);
        
        String leader = map.get(team);
        System.out.println("Leader of " + team.getName() + " is " + leader);
    }
}
Output:
Leader of Team 1 is null
Voir plus sur la manière dont HashMap, WeakHashMap et IdentityHashMap stockent leurs données pour comprendre les contenus susmentionnés.

View more Tutorials:

Peut-être que vous êtes intéressé

Voici des leçons en ligne à part du site web o7planning que nous recommandons. La liste comprend des leçons en ligne et celles en promo.