Question Java String.equals versus == [dupliquer]


Cette question a déjà une réponse ici:

Ce code sépare une chaîne en jetons et les stocke dans un tableau de chaînes, puis compare une variable avec la première maison ... pourquoi ne fonctionne-t-elle pas?

public static void main(String...aArguments) throws IOException {

    String usuario = "Jorman";
    String password = "14988611";

    String strDatos = "Jorman 14988611";
    StringTokenizer tokens = new StringTokenizer(strDatos, " ");
    int nDatos = tokens.countTokens();
    String[] datos = new String[nDatos];
    int i = 0;

    while (tokens.hasMoreTokens()) {
        String str = tokens.nextToken();
        datos[i] = str;
        i++;
    }

    //System.out.println (usuario);

    if ((datos[0] == usuario)) {
        System.out.println("WORKING");
    }
}

471
2018-04-20 08:22


origine


Réponses:


Utilisez le string.equals(Object other) fonction de comparer les chaînes, pas la == opérateur.

La fonction vérifie le contenu réel de la chaîne, le == L'opérateur vérifie si les références aux objets sont égales. Notez que les constantes de chaîne sont généralement "internées" de sorte que deux constantes de même valeur peuvent être comparées à ==, mais il vaut mieux ne pas compter sur ça.

if (usuario.equals(datos[0])) {
    ...
}

NB: la comparaison est faite sur 'usuario' car cela garantit la non-nullité de votre code, même si vous devez quand même vérifier que vous avez effectivement des jetons dans le code. datos tableau sinon, vous obtiendrez une exception de type tableau hors limites.


510
2018-04-20 08:25



Rencontrez Jorman

Jorman est un homme d'affaires prospère et a 2 maisons.

enter image description here

Mais d'autres ne le savent pas.

Est-ce le même Jorman?

Lorsque vous interrogez des voisins des rues Madison ou Burke, c'est la seule chose qu'ils peuvent dire:

enter image description here

En utilisant la résidence seule, il est difficile de confirmer que c'est le même Jorman. Comme ils sont 2 adresses différentes, il est naturel de supposer que ce sont 2 personnes différentes.

Voilà comment l'opérateur == se comporte. Donc ça va dire ça datos[0]==usuario est faux, car seulement compare les adresses.

Un enquêteur à la rescousse

Et si nous envoyions un enquêteur? Nous savons que c'est le même Jorman, mais nous devons le prouver. Notre détective examinera de près tous les aspects physiques. Avec une enquête approfondie, l'agent sera en mesure de déterminer si c'est la même personne ou non. Voyons le voir en termes de Java.

Voici le code source de String's equals() méthode:

enter image description here

Il compare le caractère Strings par caractère, pour arriver à la conclusion qu'ils sont bien égaux.

Voilà comment la chaîne equals la méthode se comporte. Alors datos[0].equals(usuario) renverra true, car il effectue un comparaison logique.


494
2018-04-24 14:18



Il est bon de noter que Dans certains cas, l'utilisation de l'opérateur "==" peut conduire au résultat attendu, car la façon dont Java gère les chaînes - les littéraux de chaîne sont internés (voir String.intern()) lors de la compilation - donc quand vous écrivez par exemple "hello world" dans deux classes et comparer ces chaînes avec "==", vous pouvez obtenir un résultat: vrai, ce qui est attendu selon spécification; lorsque vous comparez les mêmes chaînes (si elles ont la même valeur) lorsque la première est une chaîne littérale (c'est-à-dire définie par "i am string literal") et la seconde est construite pendant l'exécution ie. avec "nouveau" mot-clé comme new String("i am string literal"), la == L'opérateur (égalité) renvoie false, car les deux sont des instances différentes du String classe.

Seul le bon moyen utilise .equals()-> datos[0].equals(usuario).  == ne dit que si deux objets sont la même instance d'objet (ie. ont la même adresse mémoire)

Mettre à jour: 01.04.2013 J'ai mis à jour ce post pour des commentaires ci-dessous qui sont en quelque sorte corrects. À l'origine, j'ai déclaré que l'internalisation (String.intern) est un effet secondaire de l'optimisation JVM. Bien que cela économise certainement des ressources de mémoire (ce que je voulais dire par "optimisation"), il s'agit principalement de la langue


88
2018-04-20 10:12



equals() fonction est une méthode de Object classe qui devrait être remplacée par le programmeur. String La classe l'écrase pour vérifier si deux chaînes sont égales, c'est-à-dire dans le contenu et non dans la référence.

== l'opérateur vérifie si les références des deux objets sont identiques.

Considérez les programmes

String abc = "Awesome" ;
String xyz =  abc;

if(abc == xyz)
     System.out.println("Refers to same string");

Ici le abc et xyz, les deux se réfèrent à la même String  "Awesome". D'où l'expression (abc == xyz) est true.

String abc = "Hello World";
String xyz = "Hello World";

if(abc == xyz)
    System.out.println("Refers to same string");
else
    System.out.println("Refers to different strings");

if(abc.equals(xyz))
     System.out.prinln("Contents of both strings are same");
else
     System.out.prinln("Contents of strings are different");

Ici abc et xyz sont deux chaînes différentes avec le même contenu "Hello World". D'où ici l'expression (abc == xyz) est false tandis que (abc.equals(xyz)) est true.

J'espère que vous avez compris la différence entre == et <Object>.equals() 

Merci.


30
2018-03-11 03:24



Au lieu de

datos[0] == usuario

utilisation

datos[0].equals(usuario)

== compare la référence de la variable où .equals() compare les valeurs qui correspondent à ce que vous voulez.


26
2018-04-20 08:25



== tests pour l'égalité de référence.

.equals() tests pour l'égalité des valeurs.

Par conséquent, si vous voulez réellement tester si deux chaînes ont la même valeur, vous devez utiliser .equals() (sauf dans quelques situations où vous pouvez garantir que deux chaînes de même valeur seront représentées par le même objet, par exemple: String internement).

== est de tester si deux chaînes sont identiques Object.

// 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 

// concatenation of string literals happens at compile time resulting in same objects
"test" == "te" + "st"  ==> true

// but .substring() is invoked at runtime, generating distinct objects
"test" == "!test".substring(1) ==> false

Il est important de noter que == est beaucoup moins cher que equals() (une comparaison de pointeur unique au lieu d'une boucle), ainsi, dans les situations où il est applicable (c'est-à-dire que vous pouvez garantir que vous ne traitez que des chaînes internées), il peut présenter une amélioration importante des performances. Cependant, ces situations sont rares.


21
2018-01-04 05:36



The == operator checks if the two references point to the same object or not.
.equals() checks for the actual string content (value).

Notez que la méthode .equals () appartient à la classe Object (super classe de toutes les classes). Vous devez le remplacer selon vos exigences de classe, mais pour String, il est déjà implémenté et il vérifie si deux chaînes ont la même valeur ou non.

Case1)
String s1 = "Stack Overflow";
String s2 = "Stack Overflow";
s1 == s1;      // true
s1.equals(s2); // true
Reason: String literals created without null are stored in the string pool in the permgen area of the heap. So both s1 and s2 point to the same object in the pool.
Case2)
String s1 = new String("Stack Overflow");
String s2 = new String("Stack Overflow");
s1 == s2;      // false
s1.equals(s2); // true
Reason: If you create a String object using the `new` keyword a separate space is allocated to it on the heap.

16
2017-07-25 05:10



Cela fonctionnera également si vous appelez intern() sur la chaîne avant de l'insérer dans le tableau. Les chaînes internées sont égales à la référence (==) si et seulement s'ils sont égaux en valeur (equals().)

public static void main (String... aArguments) throws IOException {

String usuario = "Jorman";
String password = "14988611";

String strDatos="Jorman 14988611";
StringTokenizer tokens=new StringTokenizer(strDatos, " ");
int nDatos=tokens.countTokens();
String[] datos=new String[nDatos];
int i=0;

while(tokens.hasMoreTokens()) {
    String str=tokens.nextToken();
    datos[i]= str.intern();            
    i++;
}

//System.out.println (usuario);

if(datos[0]==usuario) {  
     System.out.println ("WORKING");    
}

11
2018-02-06 07:07



Analysons le Java suivant, pour comprendre l'identité et l'égalité des chaînes:

public static void testEquality(){
    String str1 = "Hello world.";
    String str2 = "Hello world.";

    if (str1 == str2)
        System.out.print("str1 == str2\n");
    else
        System.out.print("str1 != str2\n");

    if(str1.equals(str2))
        System.out.print("str1 equals to str2\n");
    else
        System.out.print("str1 doesn't equal to str2\n");

    String str3 = new String("Hello world.");
    String str4 = new String("Hello world.");

    if (str3 == str4)
        System.out.print("str3 == str4\n");
    else
        System.out.print("str3 != str4\n");

    if(str3.equals(str4))
        System.out.print("str3 equals to str4\n");
    else
        System.out.print("str3 doesn't equal to str4\n");
}

Quand la première ligne de code String str1 = "Hello world." exécute, une chaîne \Hello world." est créé, et la variable str1 s'y réfère. Une autre chaîne "Hello world." ne sera pas créé à nouveau lorsque la ligne de code suivante s'exécute en raison de l'optimisation. La variable str2 se réfère également à l'existant ""Hello world.".

L'opérateur == vérifie l'identité de deux objets (si deux variables se réfèrent au même objet). Depuis str1 et str2 se référer à la même chaîne en mémoire, ils sont identiques les uns aux autres. La méthode equals vérifie l'égalité de deux objets (si deux objets ont le même contenu). Bien sûr, le contenu de str1 et str2sont identiques.

Quand le code String str3 = new String("Hello world.") exécute une nouvelle instance de chaîne avec du contenu "Hello world." est créé, et il est désigné par la variable str3. Et puis une autre instance de chaîne avec du contenu "Hello world." est créé à nouveau, et référencé par str4. Depuis str3 et str4 se référer à deux cas différents, ils ne sont pas identiques, mais leur le contenu est le même.

Par conséquent, la sortie contient quatre lignes:

Str1 == str2

Str1 equals str2

Str3! = str4

Str3 equals str4

10
2018-03-12 05:17