Les deux méthode égale() et le == opérateur sont utilisés pour comparer deux objets en Java.
Le Méthode Java chaîne égale () , compare deux chaînes et renvoie vrai si tous les caractères correspondent dans les deux chaînes, sinon renvoie faux.
Le == opérateur compare la référence ou l'emplacement mémoire des objets dans un tas, qu'ils pointent vers le même emplacement ou non.
Chaque fois que nous créons un objet en utilisant l'opérateur nouveau , cela créera un nouvel emplacement mémoire pour cet objet. Nous utilisons donc l'opérateur == pour vérifier que l'emplacement mémoire ou l'adresse de deux objets sont identiques ou non.
En général, les opérateurs égal à () et == dans Java sont utilisés pour comparer des objets afin de vérifier l'égalité, mais voici quelques-unes des différences entre les deux :
- La principale différence entre le Méthode .equals() et le == opérateur est que l’une est une méthode et l’autre l’opérateur.
- Nous pouvons utiliser les opérateurs == pour la comparaison de références ( comparaison d'adresses ) et la méthode .equals() pour comparaison de contenu . En termes simples, == vérifie si les deux objets pointent vers le même emplacement mémoire tandis que .equals() évalue la comparaison des valeurs des objets.
- Si une classe ne le fait pas remplacer la méthode égale , puis par défaut, il utilise la méthode equals(Object o) de la classe parent la plus proche qui a remplacé cette méthode. **Voir Pourquoi remplacer les méthodes equals(Object) et hashCode() ? en détail.
Exemple:
Méthode String equals() et opérateur == en Java.
Java
commande git push
// Java program to understand> // the concept of == operator> public> class> Test {> >public> static> void> main(String[] args)> >{> >String s1 =>'HELLO'>;> >String s2 =>'HELLO'>;> >String s3 =>new> String(>'HELLO'>);> >System.out.println(s1 == s2);>// true> >System.out.println(s1 == s3);>// false> >System.out.println(s1.equals(s2));>// true> >System.out.println(s1.equals(s3));>// true> >}> }> |
>
>Sortir
true false true true>
Explication: Ici, nous créons deux objets, à savoir s1 et s2.
- s1 et s2 font référence aux mêmes objets.
- Lorsque nous utilisons l'opérateur == pour la comparaison s1 et s2, le résultat est vrai car les deux ont les mêmes adresses dans le chaîne piscine constante.
- En utilisant égal, le résultat est vrai car il compare uniquement les valeurs données dans s1 et s2.
Pool de chaînes Java
| s1 = BONJOUR |
| s2 = BONJOUR |
Tas Java
| s3 = BONJOUR |
Comprenons les deux opérateurs en détail :
exemple de nom d'utilisateur
Opérateur d'égalité (==)
Nous pouvons appliquer des opérateurs d'égalité pour chaque type primitif, y compris le type booléen. Nous pouvons également appliquer des opérateurs d'égalité pour les types d'objets.
Exemple:
== opérateur en Java.
Java
// Java program to illustrate> // == operator for compatible data> // types> class> Test {> >public> static> void> main(String[] args)> >{> >// integer-type> >System.out.println(>10> ==>20>);> >// char-type> >System.out.println(>'a'> ==>'b'>);> >// char and double type> >System.out.println(>'a'> ==>97.0>);> >// boolean type> >System.out.println(>true> ==>true>);> >}> }> |
>
vérifier la version Java sous Linux
>Sortir
false false true true>
Si nous appliquons == pour les types d'objets alors, il y a devrait être une compatibilité entre les types d'arguments (soit enfant à parent, soit parent à enfant ou même type). Sinon, nous obtiendrons une erreur de compilation.
Exemple:
Java
// Java program to illustrate> // == operator for incompatible data types> class> Test {> >public> static> void> main(String[] args)> >{> >Thread t =>new> Thread();> >Object o =>new> Object();> >String s =>new> String(>'GEEKS'>);> >System.out.println(t == o);> >System.out.println(o == s);> >// Uncomment to see error> >System.out.println(t==s);> >}> }> |
>
>
Sortir:
false false // error: incomparable types: Thread and String>
Méthode Java String égale()
En Java, le Méthode chaîne égale() compare les deux chaînes données en fonction des données/contenu de la chaîne. Si tout le contenu des deux chaînes est le même, cela renvoie vrai . Si tous les caractères ne correspondent pas, alors renvoie faux .
Syntaxe:
Syntaxe : public booléen égal(Objet autreObjet)
Paramètre :
carte java de l'itérateur
- un autreObjet- Chaîne à comparer
Retour:
- Valeur booléenne :
- vrai- Si les chaînes sont égales
- FAUX- si les chaînes ne sont pas égales
Exemple:
Méthode String égale () en Java
Java
quelque chose pour les petits amis
public> class> Test {> >public> static> void> main(String[] args)> >{> >Thread t1 =>new> Thread();> >Thread t2 =>new> Thread();> >Thread t3 = t1;> >String s1 =>new> String(>'GEEKS'>);> >String s2 =>new> String(>'GEEKS'>);> >System.out.println(t1 == t3);> >System.out.println(t1 == t2);> >System.out.println(s1 == s2);> >System.out.println(t1.equals(t2));> >System.out.println(s1.equals(s2));> >}> }> |
>
>
Sortir:
true false false false true>
Explication: Ici, nous utilisons la méthode .equals pour vérifier si deux objets contiennent ou non les mêmes données.
- Dans l'exemple ci-dessus, nous créons 3 objets Thread et 2 objets String.
- Dans la première comparaison, nous vérifions si t1 == t3 ou non. Comme nous le savons tous les deux t1 et t3 pointent vers le même objet . C'est pourquoi cela renvoie vrai.
- Dans la deuxième comparaison, nous utilisons l'opérateur == pour comparer les objets chaîne et non le contenu des objets. Ici, les deux objets sont différents et le résultat de cette comparaison est donc faux.
- Lorsque nous comparons 2 objets String par l'opérateur égal (), nous vérifions que les deux objets contiennent ou non les mêmes données.
- Les deux objets contiennent la même chaîne, c'est-à-dire GEEKS. C'est pourquoi cela renvoie vrai.
Lire aussi :
- Méthode Character.equals() en Java avec exemples
- ==, equals(), compareTo(), equalsIgnoreCase() et compare()
Conclusion
La méthode Java string equals() et l’opérateur == sont tous deux utilisés pour comparer des chaînes en Java. Dans ce didacticiel, nous avons couvert les méthodes ==operator et String equals() en Java avec des exemples.
Read More String Methods in Java>
Différence entre les méthodes == et .equals() – FAQ
1. Quelle est la différence entre str1 == str2 et str1 est égal à str2 ?
En Java, str1==str2 renverra true si str1 et str2 sont des chaînes avec le même contenu. En effet, les chaînes ayant le même contenu sont stockées au même emplacement.
str1.equals(str2) renverra true si str1 et str 2 sont des objets chaîne différents, mais ont le même contenu.
2. Quelle est la différence entre == et égal dans la comparaison de chaînes ?
Le méthode chaîne égale() compare deux chaînes et renvoie vrai si tous les caractères correspondent dans les deux chaînes, sinon renvoie faux.
L'opérateur == compare la référence ou l'emplacement mémoire des objets dans un tas, qu'ils pointent vers le même emplacement ou non.
3. Quelles sont les règles de la méthode equals() ?
- Réflexivité : Pour tout objet x, x.equals(x) doit toujours renvoyer true.
- Symétrie : Si x.equals(y) renvoie vrai, alors y.equals(x) doit également renvoyer vrai.
- Transitivité : Si x.equals(y) et y.equals(z) sont tous deux vrais, alors x.equals(z) doit également être vrai.
- Cohérence : Plusieurs invocations de x.equals(y) devraient renvoyer le même résultat.
- Non-nullité : La méthode equals() ne doit jamais renvoyer true par rapport à null.