Comment comparer des chaînes de caractères en Java ?

Question

J'ai utilisé le == dans mon programme pour comparer toutes mes chaînes de caractères jusqu'à présent. Cependant, j'ai rencontré un bug, j'ai changé l'une d'entre elles en .equals() à la place, et cela a corrigé le bug.

Est == mauvais ? Quand faut-il l'utiliser et quand ne faut-il pas l'utiliser ? Quelle est la différence ?

Answer 1

== teste l'égalité des références (s'il s'agit du même objet).

.equals() des tests d'égalité des valeurs (si elles sont logiquement "égales").

Objets.equals() contrôles pour null avant d'appeler .equals() pour que vous n'ayez pas à le faire (disponible à partir de JDK7, également disponible en Goyave ).

Par conséquent, si vous voulez tester si deux chaînes de caractères ont la même valeur, vous voudrez probablement utiliser Objects.equals() .

// These two have the same value
new String("test").equals("test") // --> true 

// ... but they are not the same object
new String("test") == "test" // --> false 

// ... neither are these
new String("test") == new String("test") // --> false 

// ... but these are because literals are interned by 
// the compiler and thus refer to the same object
"test" == "test" // --> true 

// ... string literals are concatenated by the compiler
// and the results are interned.
"test" == "te" + "st" // --> true

// ... but you should really just call Objects.equals()
Objects.equals("test", new String("test")) // --> true
Objects.equals(null, "test") // --> false
Objects.equals(null, null) // --> true

Tu as presque toujours veulent utiliser Objects.equals() . Dans le rare situation où vous connaître vous avez affaire à interné les cordes, vous peut utiliser == .

De JLS 3.10.5. Littéraux de chaîne :

De plus, un littéral de chaîne de caractères fait toujours référence à l'élément même instance de la classe String . En effet, les chaînes littérales - ou, plus généralement, les chaînes de caractères qui sont les valeurs d'expressions constantes ( §15.28 ) - sont "internés" de manière à partager des instances uniques, en utilisant la méthode String.intern .

On trouve également des exemples similaires dans JLS 3.10.5-1 .

Autres méthodes à envisager

String.equalsIgnoreCase() l'égalité des valeurs qui ignore la casse. Attention, cependant, cette méthode peut avoir des résultats inattendus dans divers cas liés à la localisation, cf. cette question .

String.contentEquals() compare le contenu de la String avec le contenu de tout CharSequence (disponible depuis Java 1.5). Elle vous évite de devoir transformer votre StringBuffer, etc. en String avant d'effectuer la comparaison d'égalité, mais vous laisse le soin de vérifier les nullités.

Answer 2

== teste les références d'objets, .equals() teste les valeurs des chaînes de caractères.

Parfois, on a l'impression que == compare les valeurs, car Java effectue des opérations en coulisse pour s'assurer que des chaînes de caractères identiques en ligne sont bien le même objet.

Par exemple :

String fooString1 = new String("foo");
String fooString2 = new String("foo");

// Evaluates to false
fooString1 == fooString2;

// Evaluates to true
fooString1.equals(fooString2);

// Evaluates to true, because Java uses the same object
"bar" == "bar";

Mais attention aux nuls !

== poignées null les cordes sont bien, mais appeler .equals() à partir d'une chaîne nulle provoquera une exception :

String nullString1 = null;
String nullString2 = null;

// Evaluates to true
System.out.print(nullString1 == nullString2);

// Throws a NullPointerException
System.out.print(nullString1.equals(nullString2));

Donc si vous savez que fooString1 peut être nulle, dites au lecteur qu'en écrivant

System.out.print(fooString1 != null && fooString1.equals("bar"));

Les suivantes sont plus courtes, mais il est moins évident qu'elles vérifient la présence de null :

System.out.print("bar".equals(fooString1));  // "bar" is never null
System.out.print(Objects.equals(fooString1, "bar"));  // Java 7 required

Answer 3

== compare les références d'objets.

.equals() compare des valeurs de type String.

Parfois == donne l'illusion de comparer les valeurs des chaînes, comme dans les cas suivants :

String a="Test";
String b="Test";
if(a==b) ===> true

En effet, lorsque vous créez un littéral de chaîne, la JVM recherche d'abord ce littéral dans le pool de chaînes, et si elle trouve une correspondance, cette même référence sera donnée à la nouvelle chaîne. De ce fait, nous obtenons :

(a==b) ===> vrai

                       String Pool
     b -----------------> "test" <-----------------a

Cependant, == échoue dans le cas suivant :

String a="test";
String b=new String("test");
if (a==b) ===> false

Dans ce cas, pour new String("test") l'instruction new String sera créée sur le tas, et cette référence sera donnée à b donc b se verra attribuer une référence sur le tas, et non dans le pool String.

Maintenant a pointe vers une chaîne dans le pool de chaînes alors que b pointe vers une chaîne sur le tas. A cause de cela, nous obtenons :

si(a==b) ===> faux.

                String Pool
     "test" <-------------------- a

                   Heap
     "test" <-------------------- b

Alors que .equals() compare toujours une valeur de String, donc il donne vrai dans les deux cas :

String a="Test";
String b="Test";
if(a.equals(b)) ===> true

String a="test";
String b=new String("test");
if(a.equals(b)) ===> true

Donc, en utilisant .equals() est toujours mieux.

Answer 4

Le site == L'opérateur vérifie si les deux chaînes de caractères sont exactement le même objet.

Le site .equals() vérifiera si les deux chaînes de caractères ont la même valeur.

Answer 5

Les chaînes de caractères en Java sont immuables. Cela signifie que chaque fois que vous essayez de changer/modifier la chaîne, vous obtenez une nouvelle instance. Vous ne pouvez pas modifier la chaîne originale. Cela a été fait pour que ces instances de chaînes puissent être mises en cache. Un programme typique contient beaucoup de références de chaînes de caractères et la mise en cache de ces instances peut réduire l'empreinte mémoire et augmenter les performances du programme.

Lorsque vous utilisez l'opérateur == pour comparer des chaînes de caractères, vous ne comparez pas le contenu de la chaîne, mais vous comparez en fait l'adresse mémoire. S'ils sont tous deux égaux, l'opérateur renvoie true (vrai), sinon false (faux). Alors que equals dans une chaîne de caractères compare le contenu de la chaîne.

Donc la question est que si toutes les chaînes sont mises en cache dans le système, comment se fait-il que == renvoie faux alors que equals renvoie vrai ? Eh bien, c'est possible. Si vous créez une nouvelle chaîne de caractères comme String str = new String("Testing") vous finissez par créer une nouvelle chaîne dans le cache, même si le cache contient déjà une chaîne ayant le même contenu. En bref "MyString" == new String("MyString") retournera toujours false.

Java parle également de la fonction intern() qui peut être utilisée sur une chaîne de caractères pour l'intégrer dans le cache. "MyString" == new String("MyString").intern() retournera vrai.

Remarque : l'opérateur == est beaucoup plus rapide que equals simplement parce que vous comparez deux adresses mémoire, mais vous devez être sûr que le code ne crée pas de nouvelles instances de String dans le code. Sinon, vous rencontrerez des bogues.