Exemple de code qui explique en détail les différences et les connexions entre ==, égal et hashCode en Java

1. Présentation

1. Concept

• == : Le fonctionnement Le symbole génère un résultat booléen, qui calcule la relation entre les valeurs des opérandes

• est égal à : La méthode d'instance Object , compare le contenu objets 🎜>Est-ce la même chose

• hashCode : méthode native de l'objet, obtenez l'objet La valeur de hachage est utilisée pour déterminer la position index de l'objet dans la table de hachage. Il s'agit en fait d'un type intentier

2. Opérateurs relationnels==

---

1. Valeur de l'opérande

Basique
• Type de données

  VariableIl existe huit types de données de base en Java :

  　

  Type à virgule flottante

   : float(4 octet), double (8 octets) Type entier : octet (1 octet), court (2 octets), int (4 octets), long (8 octets)

  Type de caractère : char (2 octets)

  Type booléen : booléen (la spécification JVM ne précise pas clairement la taille de l'espace qu'elle occupe, mais stipule seulement qu'elle ne peut prendre que les valeurs littérales "vrai" et "faux")

  　

  Pour les variables de ces huit types de données de base, les variables stockent directement des « valeurs ». Par conséquent, lors d'une comparaison à l'aide de l'opérateur relationnel ==, ce qui est comparé est la « valeur » elle-même. Il convient de noter que virgule flottante et entier sont tous deux de types signés (le bit le plus élevé n'est utilisé que pour représenter le positif et le négatif, et ne participe pas au calcul [Prendre l'octet comme exemple , sa plage est -2^7 ~ 2^7 - 1, -0 est -128]), et char est un type non signé (tous les bits sont impliqués dans le calcul, donc la plage de valeurs du type char est 0~2 ^16-1).

---

• Référence

  variable de type En Java, les variables de
  type référence sont stockées Pas le "valeur" elle-même, mais l'adresse en mémoire de l'objet qui lui est associé . Par exemple, la ligne de code suivante,

Cette phrase déclare une variable de type référence, qui n'est associée à aucun objet pour le moment.

    String str1;

Et utilisez

new
pour générer un objet et lier cet objet à str1 :

Ensuite str1 pointe vers cet objet, et à ce moment,

str1= new String("hello");

fait référence à What est stocké dans la variable str1 est l'adresse de stockage de l'objet vers lequel il pointe dans la mémoire, pas la "valeur" elle-même, c'est-à-dire qu'il ne s'agit pas d'une

chaîne "bonjour" directement stockée . Les références ici sont très similaires aux pointeurs en C/C.

2. Résumé

---

Donc, pour l'opérateur relationnel == :

Si le type de l'opérande est

• Type de données de base , puis l'opérateur relationnel détermine si les valeurs des opérandes gauche et droit sont égales

Si le type de l'opérande est

• type de données de référence , alors l'opérateur relationnel détermine l' adresse mémoire de gauche et les opérandes de droite sont-ils les mêmes. En d'autres termes, si true est renvoyé à ce moment-là, l'opérateur doit agir sur le même objet.

3. Méthode égale

---

1 Source

La méthode égale est une méthode d'instance dans la classe de base Object, donc pour toutes les classes qui

héritent
d'Object auront cette méthode. 　　Déclaration dans l'objet :

    public boolean equals(Object obj) {}

2. Le rôle de la méthode égale

---

　

Intention originale :
Juger la différence entre deux objets Le contenu est-il le même ? Afin de comprendre le rôle de la méthode equals de manière plus intuitive, regardons d'abord l'implémentation de la méthode equals dans la classe

Object

.

Évidemment,

  public boolean equals(Object obj) {    return (this == obj);
  }

Dans la classe Object, la méthode equals est utilisée pour comparer si les références de deux objets sont égales, c'est-à-dire si elles pointent vers le même objet.

　 但我们都知道，下面代码输出为 true:

public class Main {
    public static void main(String[] args) {
        String str1 = new String("hello");
        String str2 = new String("hello");

        System.out.println(str1.equals(str2));
    }
}

原来是 String 类重写了 equals 方法：

public boolean equals(Object anObject) {   // 方法签名与 Object类 中的一致
    if (this == anObject) {     // 先判断引用是否相同(是否为同一对象),
        return true;
    }    if (anObject instanceof String) {   // 再判断类型是否一致,
        // 最后判断内容是否一致.
        String anotherString = (String)anObject;        
        int n = count;        
        if (n == anotherString.count) {        
        char v1[] = value;        
        char v2[] = anotherString.value;        
        int i = offset;        
        int j = anotherString.offset;       
         while (n-- != 0) {            
         if (v1[i++] != v2[j++])            
         return false;
        }        return true;
        }
    }    return false;
}

即对于诸如“字符串比较时用的什么方法,内部实现如何？”之类问题的回答即为：

使用equals方法，内部实现分为三个步骤：

• 先 比较引用是否相同(是否为同一对象),

• 再 判断类型是否一致（是否为同一类型）,

• 最后 比较内容是否一致

Java 中所有内置的类的 equals 方法的实现步骤均是如此，特别是诸如 Integer，Double 等包装器类。

---

3、equals 重写原则

对象内容的比较才是设计equals()的真正目的，Java语言对equals()的要求如下，这些要求是重写该方法时必须遵循的：

• 对称性： 如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true” ；

• 自反性： x.equals(x)必须返回是“true” ；

• 类推性： 如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true” ；

• 一致性： 如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true” ；

• 对称性： 如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。

• 任何情况下，x.equals(null)【应使用关系比较符 ==】，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”

---

4、小结
　因此，对于 equals 方法：

• 其本意 是 比较两个对象的 content 是否相同

• 必要的时候，我们需要重写该方法，避免违背本意，且要遵循上述原则

---

四、hashCode 方法

1、hashCode 的来源
　　hashCode 方法是基类Object中的 实例native方法，因此对所有继承于Object的类都会有该方法。
　　
　　在 Object类 中的声明（native方法暗示这些方法是有实现体的，但并不提供实现体，因为其实现体是由非java语言在外面实现的）：

　　   public native int hashCode();

---

2、哈希相关概念
　我们首先来了解一下哈希表：

• 概念 ： Hash 就是把任意长度的输入(又叫做预映射， pre-image)，通过散列算法，变换成固定长度的输出(int)，该输出就是散列值。这种转换是一种 压缩映射，也就是说，散列值的空间通常远小于输入的空间。不同的输入可能会散列成相同的输出，从而不可能从散列值来唯一的确定输入值。简单的说，就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

• 应用–数据结构 ： 数组的特点是：寻址容易，插入和删除困难; 而链表的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入和删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法——拉链法，我们可以理解为 “链表的数组”，如图：

  　　　　　　　　　
  　　　　　　　　　　　　　　　 　　　　　　　　图1 哈希表示例

  　Le côté gauche est évidemment un tableau, et chaque membre du tableau est une liste chaînée. Tous les éléments contenus dans cette structure de données contiennent un pointeur permettant de relier les éléments. Nous attribuons des éléments à différentes listes chaînées en fonction de leurs propres caractéristiques. Nous trouvons également la liste chaînée correcte en fonction de ces caractéristiques, puis trouvons l'élément dans la liste chaînée. Parmi elles, la méthode de calcul de l'indice du tableau d'éléments en fonction des caractéristiques de l'élément est la méthode de hachage.

• Champ d'application de la méthode de fermeture éclair : Structure de données de base pour une recherche et une suppression rapides, généralement la quantité totale de données peut être mise en mémoire.

• Points clés :
  Sélection de la fonction de hachage, pour les chaînes, les entiers, les permutations, les méthodes de hachage correspondantes spécifiques
  Traitement des collisions, l'une est le hachage ouvert ; est également appelée méthode de fermeture éclair, et l'autre est le hachage fermé, également appelée méthode d'adressage ouverte.

---

3. Brève description de hashCode
En Java, La méthode hashCode définie par la classe Object renverra différents entiers pour différents objets. (Ceci est accompli en convertissant l'adresse interne de l'objet en un entier, mais le langage de programmation JavaTM ne nécessite pas cette astuce d'implémentation).

Le contrat général de hashCode est :

• Appels multiples au même objet lors de l'exécution d'une application Java La méthode hashCode doit renvoyer systématiquement le même entier, à condition que les informations utilisées pour comparer les objets égaux n'aient pas été modifiées. Cet entier n'a pas besoin d'être 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 méthode equals(Object), alors l'appel de la méthode hashCode sur chacun des deux objets doit produire le même résultat entier.

• Si les deux objets ne sont pas égaux selon la méthode equals(java.lang.Object), alors appelez hashCode sur l'une des deux méthodes <. 🎜> n'exigent pas que produise des résultats entiers différents. Cependant, les programmeurs doivent être conscients que la génération de résultats entiers différents pour des objets inégaux peut améliorer les performances des tables de hachage. 　
  Pour mieux comprendre le rôle de hashCode, nous devons d'abord comprendre le conteneur en Java,
  car HashCode n'est utile que dans les structures de données qui nécessitent des algorithmes de hachage, telles que HashSet, HashMap et Table de hachage.

  Il existe trois types de collections en Java, l'une est List, l'autre est Queue et la troisième est Set. Les éléments des deux premiers ensembles sont ordonnés et les éléments peuvent être répétés ; les éléments du dernier ensemble ne sont pas ordonnés, mais les éléments ne peuvent pas être répétés.
  Voici donc un problème plus sérieux : si vous voulez vous assurer que des éléments ne sont pas répétés, sur quelle base devez-vous juger si deux éléments sont répétés ? Il s'agit de la méthode

  Object.equals . Cependant, si vous vérifiez une fois à chaque fois qu'un élément est ajouté, alors lorsqu'il y a beaucoup d'éléments, le nombre de comparaisons d'éléments ajoutés à la collection sera très important. En d'autres termes, s'il y a 1000 éléments dans la collection, alors lorsque le 1er élément 001 est ajouté à la collection, il appellera la méthode égale 1000 fois. Cela réduira évidemment considérablement l’efficacité. Java a donc adopté le principe de la table de hachage. De cette façon, nous utilisons l'algorithme de hachage pour calculer une valeur pour chaque élément à stocker dans la collection, puis calculons la position de l'élément dans le tableau en fonction de cette valeur. Ainsi, lorsqu'un nouvel élément est ajouté à la collection, il peut être divisé en deux étapes :
  

• Appelez d'abord la méthode hashCode de cet élément, puis en fonction sur la valeur résultante calcule où l'élément doit être dans le tableau. S'il n'y a aucun élément à cette position, alors stockez-le directement à cette position

• S'il y a déjà un élément à cette position ; , Appelez ensuite sa méthode equals pour comparer avec le nouvel élément : s'il est identique, il ne sera pas stocké sinon, il sera stocké dans la liste chaînée correspondant à cette position (l'implémentation de HashSet, HashMap et Hashtable en Java. place toujours l'élément en tête de la liste chaînée).

4. égale et hashCode

---

Prérequis :

Quand il s'agit de hashCode, il faut parler à propos de la méthode égale. Les deux sont des méthodes de la classe Object. Puisque la classe Object est la classe de base de toutes les classes, ces deux méthodes peuvent être remplacées dans toutes les classes.

• Principe 1 :

  Si x.equals(y) renvoie "true", alors le hashCode() de x et y doit être égal ; 🎜>

  Principe 2 :
Si x.equals(y) renvoie "false", alors le hashCode() de x et y peut être égal ou inégal

• 原则 3 ： 如果 x 和 y 的 hashCode() 不相等，那么 x.equals(y) 一定返回 “false” ；

• 原则 4 ： 一般来讲，equals 这个方法是给用户调用的，而 hashcode 方法一般用户不会去调用 ；

• 原则 5 ： 当一个对象类型作为集合对象的元素时，那么这个对象应该拥有自己的equals()和hashCode()设计，而且要遵守前面所说的几个原则。

---

5、实现例证

　hashCode()在object类中定义如下：

public native int hashCode();

　说明是一个本地方法，它的实现是根据本地机器相关的。

　String 类是这样重写它的：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence{
    /** The value is used for character storage. */
    private final char value[];     //成员变量1

    /** The offset is the first index of the storage that is used. */
    private final int offset;      //成员变量2

    /** The count is the number of characters in the String. */
    private final int count;       //成员变量3

   /** Cache the hash code for the string */
    private int hash; // Default to 0    //非成员变量

    public int hashCode() {    int h = hash;        int len = count;         //用到成员变量3
    if (h == 0 && len > 0) {        int off = offset;         //用到成员变量2
        char val[] = value;       //用到成员变量1
            for (int i = 0; i < len; i++) {
                h = 31*h + val[off++];       //递推公式
            }
            hash = h;
        }        return h;
    }
}

对程序的解释：h =  s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]，由此可以看出，对象的hash地址不一定是实际的内存地址。

---

五、小结

• hashcode是系统用来快速检索对象而使用

• equals方法本意是用来判断引用的对象是否一致

• 重写equals方法和hashcode方法时，equals方法中用到的成员变量也必定会在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!