La différence et l'utilisation de equals() et == en Java

Dans le développement Java, il existe une solution apparemment simple, mais il y a beaucoup de sujets et de questions sur Internet, c'est-à-dire quelle est la différence entre equals() et l'opérateur ==

• == ? L'opérateur est utilisé pour comparer deux adresses d'objets égales
• equals() : la méthode est utilisée pour comparer si le contenu de deux objets est égal

Introduction du contenu d'aujourd'hui, cela prend environ 9 minutes

Images

Afin de mieux comprendre cette différence, regardons un exemple :

String str1 = new String("Hello");String str2 = new String("Hello");System.out.println(str1.equals(str2)); // 输出 trueSystem.out.println(str1 == str2); // 输出 false

Dans l'exemple, bien que le contenu des deux chaînes soit le même, leurs adresses en mémoire sont différentes. Par conséquent, l'utilisation de la méthode .equals() pour comparer leur contenu renverra vrai, tandis que l'utilisation de l'opérateur "==" pour comparer leurs adresses renverra faux

1 Remplacez la méthode .equals()

Si vous avez appris la méthode. bases de Java, vous devez savoir que toutes les classes de Java héritent de la classe Object par défaut. Il existe une méthode .equals() dans la classe Object

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

D'après le code, vous pouvez constater que la méthode .equals(). utilise l'opérateur == pour la comparaison par défaut. Si la sous-classe n'est pas remplacée par la méthode égal (), utilisez l'opérateur == et la méthode égal (), le résultat est exactement le même - utilisé pour comparer si les adresses mémoire de deux les objets sont égaux.

Mais la situation réelle est qu'il existe de nombreuses classes qui remplacent la méthode equals(). En effet, les exigences de comparaison des adresses mémoire sont strictes et ne répondent pas aux besoins de tous les scénarios réels. Par exemple, la classe String, lors de la comparaison, la plupart d'entre eux veulent juste juger du contenu. Je ne veux pas vraiment savoir si les adresses mémoire sont égales (si elles sont un objet).

Dans l'article sur l'étude approfondie du pool constant de chaînes Java, nous avons appris que la machine virtuelle Java alloue un espace séparé pour les chaînes - le pool constant de chaînes - afin d'optimiser l'utilisation de la mémoire et d'améliorer les performances.

Il est recommandé de créer un objet chaîne en utilisant String s = "Hello" au lieu d'utiliser le nouveau mot-clé, car new nécessite une allocation supplémentaire d'espace mémoire sur le tas.

1.1. La méthode equals() de la classe String

La méthode equals() de la classe String de Jdk11

public boolean equals(Object anObject) { //如果是同一个对象（即两个引用指向内存中的同一块地址），则直接返回trueif (this == anObject) {return true;} //如果是String类型的实例if (anObject instanceof String) { //Object类型的对象强制转换为String类型String aString = (String)anObject;//如果当前字符串对象和传入的字符串对象的编码方式相同if (coder() == aString.coder()) { //如果当前字符串和传入的字符串都是Latin1编码，则调用StringLatin1类的equals方法进行比较；如果其中一个或两个字符串是UTF16编码，则调用StringUTF16类的equals方法进行比较return isLatin1() ? StringLatin1.equals(value, aString.value): StringUTF16.equals(value, aString.value);}}return false;}

Notes spéciales : Latin1 (également connu sous le nom d'ISO 8859-1) et UTF-16 (Unicode format de conversion 16 bits) sont deux méthodes de codage de caractères différentes

Latin1 et UTF-16 sont deux méthodes de codage, mais la différence n'est pas grande. Prenez la méthode equals() de UTF-16 pour voir

@HotSpotIntrinsicCandidatepublic static boolean equals(byte[] value, byte[] other) {if (value.length == other.length) {int len = value.length >> 1;for (int i = 0; i 

Remarque : Java8 Le code source de la méthode Equals() de Java11 est différent de la méthode Equals() du JDK8

public boolean equals(Object anObject) {// 如果是同一个对象（即两个引用指向内存中的同一块地址），则直接返回trueif (this == anObject) {return true;}// 如果是String类型的实例if (anObject instanceof String) {////Object类型的对象强制转换为String类型String anotherString = (String)anObject;int n = value.length;// 如果字符串长度相等if (n == anotherString.value.length) {char v1[] = value;char v2[] = anotherString.value;int i = 0;// 判断每个字符是否相等while (n-- != 0) {if (v1[i] != v2[i])return false;i++;}return true;}}return false;}

1.2 Exemple de description

Exemple 1 :

new String("hello").equals("hello")

Quel est le résultat de sortie

Comparaison ? de la méthode equals de la classe String est de savoir si le contenu des objets chaîne est égal. Parce qu'ils sont tous "Bonjour", le résultat est vrai

Exemple 2 :

new String("hello") == "hello";

Quel est le résultat de sortie ?

= = Si les adresses d'objet comparées par l'opérateur sont égales, = = Le côté gauche est l'objet créé dans le tas et le côté droit est l'objet pool de constantes de chaîne. Bien que le contenu soit égal, les adresses ne sont pas égales, donc le. le résultat est faux

Exemple 3 :

new String("hello") == new String("hello");

Quel est le résultat de sortie ?

nouvel objet Il doit s'agir d'une adresse mémoire complètement différente, donc le résultat est faux

Exemple 4 :

"hello" == "h"+"ello"

Quel est le résultat de sortie ?

h et ello sont tous deux dans le pool de constantes de chaîne, donc lorsque le compilateur rencontre l'opérateur +, optimisez-le automatiquement en hello, donc le résultat est vrai

Exemple 5 :

new String("hello").intern() == "hello"

Quel est le résultat de sortie ?

new String("hello") Une fois exécuté, un objet sera d'abord créé dans le pool de constantes de chaîne, puis créera l'objet dans le tas lors de l'exécution de la méthode intern(), il s'avère que l'objet 'hello' ; ' existe déjà dans le pool de constantes de chaîne, il renvoie donc directement la référence d'objet dans le pool de constantes de chaîne, puis la compare avec la comparaison de chaîne 'hello' dans le pool de constantes, donc le résultat est vrai

Analyse approfondie de String.intern() a déjà présenté les raisons

2. Comparaison d'autres méthodes

En plus de la méthode .equals() et de l'opérateur "==" , il existe d'autres méthodes de comparaison qui peuvent être utilisées :

• 1. Méthode Objects.equals() : Cette méthode statique peut être utilisée pour comparer si deux objets sont égaux, et il n'est pas nécessaire de déterminer si l'objet est vide avant d'appeler.

Objects.equals("Hello", new String("Hello")); // 返回 true

• 2. La méthode .contentEquals() de la classe String : Cette méthode peut être utilisée pour comparer si une chaîne est égale à une séquence de caractères (telle que StringBuffer, StringBuilder, String, CharSequence).

String str = "Hello";StringBuffer buffer = new StringBuffer("Hello");System.out.println(str.contentEquals(buffer)); // 输出 true