Exemple de partage de code pour implémenter la méthode hashCode en Java

Vous connaissez l'identité unique d'un objet ne peut pas simplement être en écrivant un joli égal Implémenter le

est génial, mais maintenant vous devez également implémenter la méthode hashCode Voyons pourquoi et comment le faire correctement 🎜>

Égalité et hachage. Code

L'égalité est d'un point de vue général, les codes de hachage sont plus techniques, et si on a du mal à comprendre, on peut dire qu'ils ne sont qu'un détail d'implémentation pour améliorer les performances

La plupart des données. les structures utilisent la méthode equals pour déterminer si elles contiennent un élément. Par exemple :

Cette

variable

List<String> list = Arrays.asList("a", "b", "c");
boolean contains = list.contains("b");

contient les résultats en true , car, bien que "b" ne soit pas la même instance. (de plus, ignorer la chaîne résidente), ils sont égaux en comparant chaque élément de

puis en attribuant le résultat de la comparaison à est plus inutile, bien que la structure des données de la classe entière ait été optimisée pour améliorer

Ils effectuent des comparaisons en utilisant une méthode de raccourci (réduisant l'égalité potentielle des instances), au lieu de comparer les instances. La comparaison de raccourci ne doit comparer que les aspects suivants : contains

Raccourci. La comparaison consiste à remplacer une instance par une valeur entière en comparant le code de hachage. Pas nécessairement égale, mais les instances égales doivent avoir la même valeur de hachage (ou devraient, nous en discuterons sous peu. Ces structures de données sont souvent nommées en utilisant cette technique). et peut être identifié par

Parmi eux,

est le représentant le plus célèbre d'entre eux

Hash Ils fonctionnent généralement comme ça HashMap

Quand un élément. est ajouté, son code de hachage est ajouté est utilisé pour calculer l'

index
• (le soi-disant seau) du

  tableau

  interne. Si tel est le cas, les éléments inégaux ont les mêmes codes de hachage, ils se retrouvent sur le même bucket et sont regroupés, par exemple en ajoutant à la liste

• Lorsqu'une instance arrive pour le
. opération, son code de hachage sera utilisé. Pour calculer la valeur du bucket (valeur d'index), les instances ne seront comparées que lorsqu'il y a un élément sur la valeur d'index correspondante. Par conséquent,
• ,

  sont définis dans <. code>Objectcontains classe

Méthode de hachage

Si

est utilisé comme raccourci pour déterminer l'égalité, alors il n'y a qu'une seule chose dont nous devons nous soucier : les objets égaux doivent avoir le même code de hachage, c'est pourquoi si nous remplaçons la méthode equals Enfin, nous devons créer une implémentation hashCode correspondante ! <a href="http://www.php.cn/wiki/60.html" target="_blank">Object</a>

Sinon, les objets égaux peuvent ne pas avoir le même code de hachage, car ils appelleront la valeur par défaut de

accompli.

hashCode Lignes directricesequalshashCode

Citation

de la documentation officielleObject's

Convention générale hashCode :HashCode* Appeler l'application Java en cours d'exécution Pour le même objet, la méthode hashCode doit toujours renvoyer le même entier. Il n'est pas nécessaire que cet entier soit cohérent entre les différentes applications Java.

* Comparez selon la méthode equals(Object). Si deux objets sont égaux, l'appel de la méthode hashCode sur les deux objets doit produire le même résultat.

* Selon la méthode equals(Object), si les deux objets ne sont pas égaux, alors appeler la méthode hashCode sur les deux objets ne produira pas nécessairement des résultats entiers différents. Cependant, les programmeurs doivent être conscients que la production de résultats entiers différents pour des objets inégaux améliorera potentiellement les performances de la table de hachage.

Le premier point reflète l'attribut
de cohérence égale
, et le second est l'exigence que nous avons formulée ci-dessus. La troisième illustre un détail important dont nous parlerons plus tard.
Implémentation du HashCode

Ce qui suit est une implémentation très simple de

la personne calcule le code de hachage en combinant plusieurs champs. Ils sont tous calculés grâce à la fonction

de

. Person.hashCode

Sélectionner les champs

@Override
public int hashCode() {
    return Objects.hash(firstName, lastName);
}

Mais quels champs sont liés ? L'exigence nous aidera à répondre à cette question : si des objets égaux doivent avoir le même code de hachage, alors le calcul du code de hachage n'est pas nécessaire. Aucun champ n'est utilisé. pour la vérification de l’égalité devrait être inclus. (Sinon, les deux objets ne sont différents que dans ces champs mais peuvent quand même être égaux. Dans ce cas, les codes de hachage des deux objets seront différents.) ObjecthashIl est donc utilisé lorsque les champs du groupe de hachage doivent être égal. Un sous-ensemble de champs. Par défaut, les deux utilisent les mêmes champs, mais certains détails doivent être pris en compte.

一致性

首先,有一致性的要求。它应该相当严格。虽然它允许如果一些字段改变对应的哈希码发生变化(对于可变的类是不可避免的)，但是哈希数据结构并不是为这种场景准备的。

正如我们以上所见的哈希码用于确定元素的桶。但如果hash-relevant字段发生了改变,并不会重新计算哈希码、也不会更新内部数组。

这意味着以后通过相等的对象，甚至同一实例进行查询也会失败，数据结构计算当前的哈希码与之前存储实例计算的哈希码并不一致,并是错误的桶。

结论:最好不要使用可变字段计算哈希码!

性能

哈希码最终计算的频率与可能调用equals差不多，那么这里将是影响性能的关键部分，因此考虑此部分性能也是非常有意义的。并且与equals相比，优化之后又更大的上升空间。

除非使用非常复杂的算法或者涉及非常多的字段，那么计算哈希码的运算成本是微不足道的、同样也是不可避免的。但是也应该考虑是否需要包含所有的字段来进行运算。集合需要特别警惕的对待。以Lists和sets为例，将会包含集合里面的每一个元素来计算哈希码。是否需要调用它们需要具体情况具体分析。

如果性能是至关重要的，使用Objects.hash因为需要为varargs创建一个数组也许并不是最好的选择。但一般规则优化是适用的:不要过早地使用一个通用的散列码算法,也许需要放弃集合,只有优化分析显示潜在的改进。

碰撞

总是关注性能,这个实现怎么呢?

@Override
public int hashCode() {
    return 0;
}

快是肯定的。相等的对象将具有相同的哈希码。并且,没有可变的字段!

但是，我们之前说过的桶呢？！这种方式下所有的实例将会有相同的桶！这将会导致一个链表来包含所有的元素，这样一来将会有非常差的性能。每次调用contains将会触发对整个list线性扫描。

我们希望尽可能少的元素在同一个桶!一个算法返回变化多端的哈希码,即使对于非常相似的对象,是一个好的开始。

怎样才能达到上面的效果部分取决于选取的字段，我们在计算中包含更多的细节，越有可能获取到不同的哈希码。注意：这个与我们所说的性能是完全相反的。因此，有趣的是，使用过多或者过少的字段都会导致糟糕的性能。

防止碰撞的另一部分是使用实际计算散列的算法。

计算Hsah

最简单的方法来计算一个字段的哈希码是通过直接调用hashCode，结合的话会自动完成。常见的算法是首先在以任意数量的数值(通常是基本数据类型)反复进行相乘操作再与字段哈希码相加

int prime = 31;
int result = 1;
result = prime * result + ((firstName == null) ? 0 : firstName.hashCode());
result = prime * result + ((lastName == null) ? 0 : lastName.hashCode());
return result;

这可能导致溢出,但是不是特别有问题的,因为他们并没有产生Java异常。

注意,即使是非常良好的的哈希算法也可能因为输入特定的模式的数据有导致频繁碰撞。作为一个简单的例子假设我们会计算点的散列通过增加他们的x和y坐标。当我们处理f(x) = -x线上的点时，线上的点都满足：x + y == 0，将会有大量的碰撞。

但是:我们可以使用一个通用的算法，只到分析表明并不正确，才需要对哈希算法进行修改。

总结

我们了解到计算哈希码就是压缩相等的一个整数值：相等的对象必须有相同的哈希码，而出于对性能的考虑：最好是尽可能少的不相等的对象共享相同的哈希码。

这就意味着如果重写了equals方法，那么就必须重写hashCode方法

当实现hashCode

• 使用与equals中使用的相同的字段(或者equals中使用字段的子集)

• 最好不要包含可变的字段。

• 对集合不要考虑调用hashCode

• 如果没有特殊的输入特定的模式，尽量采用通用的哈希算法

记住hashCode性能,所以除非分析表明必要性，否则不要浪费太多的精力。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!