Chaîne.est égal à contre == [dupliquer]

Rencontrez Jorman

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

Mais d'autres ne le savent pas.

Est-ce le même Jorman?

Lorsque vous demandez aux voisins de Madison ou Burke street, c'est la seule chose qu'ils peuvent dire:

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

C'est ainsi que l'opérateur == se comporte. Donc il dira que datos[0]==usuarioest faux, car il ne compare que les adresses.

Un enquêteur à la rescousse

Et si on envoyait 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 l'enquête approfondie, l'agent sera en mesure de conclure si c'est la même personne ou non. Voyons cela se produire en Java terme.

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

Il compare les chaînes caractère par caractère, afin de conclure qu'elles sont en effet égales.

C'est ainsi que la méthode String equals se comporte. Donc datos[0].equals(usuario) retournera true, car il effectue une comparaison logique .

Il est bon de remarquer 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()) pendant la compilation - donc lorsque vous écrivez par exemple "hello world" dans deux classes et comparez ces chaînes avec "==" vous pouvez obtenir result: true, qui est attendu selon spécification; lorsque vous comparez lorsque le premier est littéral de chaîne (ie. définir par "i am string literal") et le second est construit pendant l'exécution ie. avec le mot-clé" new " comme new String("i am string literal"), l'opérateur == (equality) renvoie false, car les deux sont des instances différentes de la classe String.

Seule bonne façon est d'utiliser .equals() -> datos[0].equals(usuario). == dit seulement si deux objets sont la même instance d'objet (ie. avoir la même adresse mémoire)

Mise à jour: 01.04.2013 J'ai mis à jour ce post en raison des commentaires ci-dessous qui sont en quelque sorte justes. À l'origine j'ai déclaré que stage (Chaîne de caractères.intern) est un effet secondaire de l'optimisation de la JVM. Bien qu'il économise certainement des ressources de mémoire (ce que je voulais dire par "optimisation"), il est principalement caractéristique du langage

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

== l'opérateur vérifie si les références de ces deux objets sont les mêmes.

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 avec le même contenu "Hello World". Donc, ici, l'expression (abc == xyz) est false, où que (abc.equals(xyz)) est true.

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

Merci.

Au Lieu de

datos[0] == usuario

Utiliser

datos[0].equals(usuario)

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

== tests d'égalité de référence.

.equals() tests d'égalité de valeur.

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 interning).

== est pour 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ù elle est applicable (c'est-à-dire que vous pouvez garantir que vous ne traitez que des chaînes internes), elle peut présenter une amélioration importante des performances. Cependant, ces situations sont rares.

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

Notez que le .la méthode equals () appartient à l'objet class (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 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.

, Il fonctionnera également si vous appelez intern() sur la chaîne avant de l'insérer dans le tableau. L'internement des chaînes de référence égale-(==) si et seulement si elles sont de valeur égale (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");    
}

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");
}

Lorsque la première ligne de code String str1 = "Hello world." s'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éée à nouveau lorsque la ligne de code suivante s'exécutera à cause de l'optimisation. La variable str2 fait également référence à 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èrent à 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 str2 sont les mêmes.

Lorsque le code String str3 = new String("Hello world.") s'exécute, une nouvelle instance de string avec content "Hello world." est créée, et elle est référencée par la variable str3. Et puis une autre instance de string avec content "Hello world." est créée à nouveau, et référencée par str4. Puisque str3 et str4 se réfèrent à deux instances différentes, elles 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

Vous devez utiliser string equals pour comparer deux chaînes pour l'égalité, pas operator == qui compare simplement les références.

== opérateur compare la référence d'un objet en Java. Vous pouvez utiliser la méthode equals de string .

String s = "Test";
if(s.equals("Test"))
{
    System.out.println("Equal");
}

L'opérateur == est une simple comparaison des valeurs.
Pour les références d'objet, les (valeurs) sont les (références). Donc x = = y renvoie true si x et y font référence au même objet.

Je sais que c'est une vieille question, mais voici comment je la regarde (je trouve très utile):

Explications Techniques

En Java, toutes les variables sont soit types primitifs ou références.

(Si vous avez besoin de savoir ce qu'est une référence: les "variables d'objet" ne sont que des pointeurs vers des objets. Donc avec Object something = ..., quelque chose est vraiment une adresse en mémoire (un nombre).)

== compare les valeurs exactes. Donc, il compare si le des valeurs primitives sont les mêmes, ou si les références (adresses) sont les mêmes. C'est pourquoi == ne fonctionne souvent pas sur les chaînes; les chaînes sont des objets, et faire == sur deux variables de chaîne compare simplement si l'adresse est la même en mémoire, comme d'autres l'ont souligné. .equals() appelle la méthode de comparaison des objets, qui comparera les objets réels pointés par les références. Dans le cas des chaînes, il compare chaque caractère pour voir s'ils sont égaux.

L'intéressant la partie:

Alors pourquoi == renvoie-t-il parfois true pour les chaînes? Notez que les chaînes sont immuables. Dans votre code, si vous le faites

String foo = "hi";
String bar = "hi";

Puisque les chaînes sont immuables (lorsque vous appelez .trim() ou quelque chose, cela produit une nouvelle chaîne, ne modifiant pas l'objet d'origine pointé en mémoire), vous n'avez pas vraiment besoin de deux objets String("hi") différents. Si le compilateur est intelligent, le bytecode lira pour ne générer qu'un seul objet String("hi"). Donc, si vous le faites

if (foo == bar) ...

Juste après, ils sont pointant vers le même objet, et retournera true. Mais vous avez rarement l'intention de le faire. Au lieu de cela, vous demandez une entrée utilisateur, qui crée de nouvelles chaînes à différentes parties de la mémoire, etc. etc.

Note : Si vous faites quelque chose comme baz = new String(bar) le compilateur peut toujours comprendre que c'est la même chose. Mais le point principal est que lorsque le compilateur voit des chaînes littérales, il peut facilement optimiser les mêmes chaînes.

Je ne sais pas comment cela fonctionne en exécution, mais je suppose que la JVM ne conserve pas un liste des "chaînes en direct" et vérifiez si une même chaîne existe. (par exemple, si vous lisez deux fois une ligne d'entrée et que l'utilisateur entre deux fois la même entrée, il ne vérifiera pas si la deuxième chaîne d'entrée est la même que la première et ne les pointera pas vers la même mémoire). Cela économiserait un peu de mémoire de tas, mais c'est tellement négligeable que les frais généraux n'en valent pas la peine. Encore une fois, le fait est qu'il est facile pour le compilateur d'optimiser les chaînes littérales.

Là vous l'avez... un graveleux explication pour == vs .equals() et pourquoi il semble aléatoire.

@Melkhiah66 Vous pouvez utiliser la méthode equals au lieu de la méthode '==' pour vérifier l'égalité. Si vous utilisez intern (), il vérifie si l'objet est dans le pool s'il est présent, puis renvoie égal autrement inégal. la méthode equals utilise en interne hashcode et vous obtient le résultat requis.

public class Demo
{
  public static void main(String[] args)
  {
              String str1 = "Jorman 14988611";
    String str2 = new StringBuffer("Jorman").append(" 14988611").toString();
    String str3 = str2.intern();
    System.out.println("str1 == str2 " + (str1 == str2));           //gives false
    System.out.println("str1 == str3 " + (str1 == str3));           //gives true
    System.out.println("str1 equals str2 " + (str1.equals(str2)));  //gives true
    System.out.println("str1 equals str3 " + (str1.equals(str3)));  //gives true
  }
}

Généralement .equals est utilisé pour Object comparaison, où vous voulez vérifier si deux Objects ont une valeur identique.

== pour la comparaison de référence (les deux Objects sont-ils les mêmes Object sur le tas) et pour vérifier si le Object est null. Il est également utilisé pour comparer les valeurs des types primitifs.

Si vous allez comparer n'importe quelle valeur assignée de la chaîne, c'est-à-dire une chaîne primitive, à la fois "==" et .equals fonctionnera, mais pour le nouvel objet string, vous ne devez utiliser que .égal, et ici "= = " ne fonctionnera pas.

Exemple:

String a = "name";

String b = "name";

if(a == b) et (a.equals(b)) retournera true.

Mais

String a = new String("a");

Dans ce cas, if(a == b) sera de retour false

Il est donc préférable d'utiliser l'opérateur .equals...

Le .equals() vérifiera si les deux chaînes ont la même valeur et retournera la valeur boolean où l'opérateur == vérifie si les deux chaînes sont le même objet.

Quelqu'un a dit sur un post plus haut que == est utilisé pour int et pour vérifier les valeurs nulles. Il peut également être utilisé pour vérifier les opérations booléennes et les types de caractères.

Soyez cependant très prudent et vérifiez que vous utilisez un caractère et non une chaîne. par exemple

    String strType = "a";
    char charType = 'a';

Pour les chaînes, vous vérifieriez alors Ce serait correct

    if(strType.equals("a")
        do something

Mais

    if(charType.equals('a')
        do something else

Serait incorrect, vous devrez faire ce qui suit

    if(charType == 'a')
         do something else

a==b

Compare les références, pas les valeurs. L'utilisation de == avec des références d'objet est généralement limitée aux éléments suivants:

1. Comparer pour voir si une référence est null.

2. Comparaison de deux valeurs enum. Cela fonctionne car il n'y a qu'un seul objet pour chaque constante enum.

3. Vous voulez savoir si deux références sont au même objet

"a".equals("b")

Compare les valeurs d'égalité. Parce que cette méthode est défini dans la classe Object, à partir de laquelle toutes les autres classes sont dérivées, il est automatiquement défini pour chaque classe. Cependant, il n'effectue pas de comparaison intelligente pour la plupart des classes à moins que la classe ne la remplace. Il a été défini de manière significative pour la plupart des classes Java Core. S'il n'est pas défini pour une classe (utilisateur), il se comporte de la même manière que ==.

Utilisez Split plutôt que tokenizer, il fournira sûrement une sortie exacte pour par exemple:

string name="Harry";
string salary="25000";
string namsal="Harry 25000";
string[] s=namsal.split(" ");
for(int i=0;i<s.length;i++)
{
System.out.println(s[i]);
}
if(s[0].equals("Harry"))
{
System.out.println("Task Complete");
}

Après cela, je suis sûr que vous obtiendrez de meilleurs résultats.....