À quoi sert hashCode en Java?

En Java, obj.hashCode()renvoie une valeur. Quelle est l'utilité de ce code de hachage en programmation?

hashCode()est utilisé pour bucketing dans les Hashmises en œuvre comme HashMap, HashTable, HashSet, etc.

La valeur reçue de hashCode()est utilisée comme numéro de compartiment pour stocker les éléments de l'ensemble / de la carte. Ce numéro de compartiment est l' adresse de l'élément à l'intérieur de l'ensemble / de la carte.

Lorsque vous le faites, contains()cela prendra le code de hachage de l'élément, puis recherchera le compartiment vers lequel pointe le code de hachage. Si plus d'un élément est trouvé dans le même compartiment (plusieurs objets peuvent avoir le même code de hachage), il utilise la equals()méthode pour évaluer si les objets sont égaux, puis décide si contains()est vrai ou faux, ou décide si l'élément pourrait être ajouté ou non à l'ensemble.

Depuis le Javadoc :

Renvoie une valeur de code de hachage pour l'objet. Cette méthode est prise en charge au profit des tables de hachage telles que celles fournies par java.util.Hashtable.

Le contrat général de hashCodeest:

• Chaque fois qu'elle est invoquée sur le même objet plus d'une fois lors de l'exécution d'une application Java, la hashCodeméthode doit systématiquement renvoyer le même entier , à condition qu'aucune information utilisée dans les comparaisons égales sur l'objet ne soit modifiée. Cet entier n'a pas besoin de rester cohérent d'une exécution d'une application à une autre exécution de la même application.

• Si deux objets sont égaux selon la equals(Object)méthode, l'appel de la hashCodeméthode sur chacun des deux objets doit produire le même résultat entier.

• Il n'est pas nécessaire que si deux objets sont différents selon la equals(java.lang.Object)méthode, l'appel de la hashCodeméthode sur chacun des deux objets doit produire des résultats entiers distincts. Cependant, le programmeur doit être conscient que la production de résultats entiers distincts pour des objets inégaux peut améliorer les performances des tables de hachage.

Autant que cela soit raisonnablement pratique, la méthode hashCode définie par la classe Object renvoie des entiers distincts pour des objets distincts. (Ceci est généralement implémenté en convertissant l'adresse interne de l'objet en un entier , mais cette technique d'implémentation n'est pas requise par le langage de programmation Java.)

La valeur renvoyée par hashCode()est le code de hachage de l'objet, qui est l'adresse mémoire de l'objet en hexadécimal.

Par définition, si deux objets sont égaux, leur code de hachage doit également être égal. Si vous remplacez la equals()méthode, vous modifiez la manière dont deux objets sont mis en équivalence et l'implémentation de Object hashCode()n'est plus valide. Par conséquent, si vous remplacez la méthode equals (), vous devez également remplacer la hashCode()méthode.

Cette réponse est tirée de la documentation officielle du didacticiel Java SE 8

hashCode()est une fonction qui prend un objet et génère une valeur numérique. Le hashcode d'un objet est toujours le même si l'objet ne change pas.

Des fonctions comme HashMap, HashTable, HashSet, etc. qui doivent stocker des objets utilisera un hashCodemodulo la taille de leur tableau interne de choisir dans quelle « position de mémoire » ( par exemple la position de tableau) pour stocker l'objet.

Il y a des cas où des collisions peuvent se produire (deux objets se retrouvent avec le même hashcode), et cela, bien sûr, doit être résolu avec soin.

Bien que le hashcode ne fasse rien avec votre logique métier, nous devons nous en occuper dans la plupart des cas. Parce que lorsque votre objet est placé dans un conteneur basé sur le hachage (HashSet, HashMap ...), le conteneur place / obtient le hashcode de l'élément.

Un hashcode est un nombre généré à partir de n'importe quel objet.

C'est ce qui permet aux objets d'être stockés / récupérés rapidement dans une Hashtable.

Imaginez l' exemple simple suivant :

Sur la table devant toi. vous avez neuf boîtes, chacune marquée d'un numéro de 1 à 9. Vous avez également une pile d'objets très différents à stocker dans ces boîtes, mais une fois qu'elles sont là, vous devez être en mesure de les trouver le plus rapidement possible.

Ce dont vous avez besoin, c'est d'un moyen de décider instantanément dans quelle boîte vous avez placé chaque objet. Cela fonctionne comme un index. vous décidez de trouver le chou afin de rechercher dans quelle boîte se trouve le chou, puis allez directement dans cette boîte pour l'obtenir.

Imaginez maintenant que vous ne voulez pas vous soucier de l'index, vous voulez pouvoir trouver immédiatement à partir de l'objet dans quelle boîte il vit.

Dans l'exemple, utilisons une manière très simple de le faire: le nombre de lettres dans le nom de l'objet. Le chou va donc dans la case 7, le pois va dans la case 3, la fusée dans la case 6, le banjo dans la case 5 et ainsi de suite.

Mais qu'en est-il des rhinocéros? Il a 10 caractères, donc nous allons changer un peu notre algorithme et "boucler" pour que les objets de 10 lettres se trouvent dans la case 1, 11 lettres dans la case 2 et ainsi de suite. Cela devrait couvrir n'importe quel objet.

Parfois, une boîte contient plus d'un objet, mais si vous cherchez une fusée, il est toujours beaucoup plus rapide de comparer une cacahuète et une fusée que de vérifier tout un tas de choux, pois, banjos et rhinocéros.

C'est un code de hachage. Un moyen d'obtenir un nombre à partir d'un objet afin qu'il puisse être stocké dans une table de hachage. En Java, un code de hachage peut être n'importe quel entier, et chaque type d'objet est responsable de la génération du sien. Recherchez la méthode "hashCode" de Object.

Source - ici

L'une des utilisations de hashCode () est la construction d'un mécanisme de capture . Regardez cet exemple:

        class Point
    {
      public int x, y;

      public Point(int x, int y)
      {
        this.x = x;
        this.y = y;
      }

      @Override
      public boolean equals(Object o)
      {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Point point = (Point) o;

        if (x != point.x) return false;
        return y == point.y;
      }

      @Override
      public int hashCode()
      {
        int result = x;
        result = 31 * result + y;
        return result;
      }

class Line
{
  public Point start, end;

  public Line(Point start, Point end)
  {
    this.start = start;
    this.end = end;
  }

  @Override
  public boolean equals(Object o)
  {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    Line line = (Line) o;

    if (!start.equals(line.start)) return false;
    return end.equals(line.end);
  }

  @Override
  public int hashCode()
  {
    int result = start.hashCode();
    result = 31 * result + end.hashCode();
    return result;
  }
}
class LineToPointAdapter implements Iterable<Point>
{
  private static int count = 0;
  private static Map<Integer, List<Point>> cache = new HashMap<>();
  private int hash;

  public LineToPointAdapter(Line line)
  {
    hash = line.hashCode();
    if (cache.get(hash) != null) return; // we already have it

    System.out.println(
      String.format("%d: Generating points for line [%d,%d]-[%d,%d] (no caching)",
        ++count, line.start.x, line.start.y, line.end.x, line.end.y));
}

hashCode()est un code unique qui est généré par la JVM pour chaque création d'objet.

Nous utilisons hashCode()pour effectuer des opérations sur des algorithmes liés au hachage comme Hashtable, Hashmap, etc.

Les avantages de hashCode()rendre l'opération de recherche facile car lorsque nous recherchons un objet qui a un code unique, cela aide à trouver cet objet.

Mais on ne peut pas dire hashCode()est l'adresse d'un objet. C'est un code unique généré par JVM pour chaque objet.

C'est pourquoi de nos jours, l'algorithme de hachage est l'algorithme de recherche le plus populaire.