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
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).
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,
String str1;
new
pour générer un objet et lier cet objet à str1 :
str1= new String("hello");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 == :
Type de données de base , puis l'opérateur relationnel détermine si les valeurs des opérandes gauche et droit sont égales
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.
héritent
d'Object auront cette méthode. Déclaration dans l'objet :
public boolean equals(Object obj) {}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
public boolean equals(Object obj) { return (this == obj);
} 但我们都知道，下面代码输出为 true: 原来是 String 类重写了 equals 方法： 即对于诸如“字符串比较时用的什么方法,内部实现如何？”之类问题的回答即为： 使用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、小结 其本意 是 比较两个对象的 content 是否相同 必要的时候，我们需要重写该方法，避免违背本意，且要遵循上述原则 1、hashCode 的来源 2、哈希相关概念 概念 ： Hash 就是把任意长度的输入(又叫做预映射， pre-image)，通过散列算法，变换成固定长度的输出(int)，该输出就是散列值。这种转换是一种 压缩映射，也就是说，散列值的空间通常远小于输入的空间。不同的输入可能会散列成相同的输出，从而不可能从散列值来唯一的确定输入值。简单的说，就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。 应用–数据结构 ： 数组的特点是：寻址容易，插入和删除困难; 而链表的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入和删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法——拉链法，我们可以理解为 “链表的数组”，如图： 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 : 3. Brève description de hashCode 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. 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). 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. Si x.equals(y) renvoie "true", alors le hashCode() de x et y doit être égal ; 🎜> 原则 3 ： 如果 x 和 y 的 hashCode() 不相等，那么 x.equals(y) 一定返回 “false” ； 原则 4 ： 一般来讲，equals 这个方法是给用户调用的，而 hashcode 方法一般用户不会去调用 ； 原则 5 ： 当一个对象类型作为集合对象的元素时，那么这个对象应该拥有自己的equals()和hashCode()设计，而且要遵守前面所说的几个原则。 5、实现例证 hashCode()在object类中定义如下： 说明是一个本地方法，它的实现是根据本地机器相关的。 String 类是这样重写它的： 对程序的解释： 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!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));
}
}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 方法：四、hashCode 方法
hashCode 方法是基类Object中的 实例native方法，因此对所有继承于Object的类都会有该方法。
在 Object类 中的声明（native方法暗示这些方法是有实现体的，但并不提供实现体，因为其实现体是由非java语言在外面实现的）： public native int hashCode();
我们首先来了解一下哈希表：
图1 哈希表示例
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.
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).
4. égale et hashCode
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.
Prérequis : public native int hashCode();
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地址不一定是实际的内存地址。
五、小结
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
