String.equals versus ==

Question

Dieser Code trennt eine Zeichenkette in Token und speichert sie in einem Array von Zeichenketten, und vergleicht dann eine Variable mit dem ersten Home ... warum funktioniert es nicht?

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

Answer 1

== Tests auf Referenzgleichheit.

.equals() prüft auf Wertegleichheit.

Wenn Sie also testen wollen, ob zwei Zeichenketten den gleichen Wert haben, sollten Sie .equals() (außer in einigen wenigen Situationen, in denen Sie garantieren können, dass zwei Zeichenketten mit demselben Wert durch dasselbe Objekt dargestellt werden, z. B: String Praktika).

== dient der Prüfung, ob zwei Zeichenketten gleich sind 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

Es ist wichtig zu beachten, dass == ist viel billiger als equals() (ein einzelner Zeigervergleich anstelle einer Schleife) und kann daher in Situationen, in denen er anwendbar ist (d.h. wenn Sie garantieren können, dass Sie nur mit internierten Zeichenketten arbeiten), eine erhebliche Leistungsverbesserung darstellen. Diese Situationen sind jedoch selten.

Answer 2

Anstelle von

datos[0] == usuario

verwenden.

datos[0].equals(usuario)

== vergleicht die Referenz der Variablen, bei der .equals() vergleicht die Werte, was Sie ja auch wollen.

Answer 3

Analysieren wir das folgende Java, um die Identität und Gleichheit von Strings zu verstehen:

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

Wenn die erste Zeile des Codes String str1 = "Hello world." ausgeführt wird, eine Zeichenkette \Hello world." wird erstellt, und die Variable str1 bezieht sich darauf. Eine andere Zeichenfolge "Hello world." wird aus Optimierungsgründen bei der Ausführung der nächsten Code-Zeile nicht erneut erzeugt. Die Variable str2 verweist auch auf die bestehenden ""Hello world." .

Der Betreiber == prüft die Identität von zwei Objekten (ob zwei Variablen auf dasselbe Objekt verweisen). Da str1 y str2 auf dieselbe Zeichenfolge im Speicher verweisen, sind sie identisch miteinander. Die Methode equals prüft die Gleichheit von zwei Objekten (ob zwei Objekte den gleichen Inhalt haben). Natürlich ist der Inhalt von str1 y str2 sind gleich.

Wenn Code String str3 = new String("Hello world.") ausgeführt wird, eine neue Instanz von string mit dem Inhalt "Hello world." erstellt, auf die sich die Variable str3 . Und dann eine weitere Instanz von string mit Inhalt "Hello world." wird erneut erstellt und durch str4 . Desde str3 y str4 sich auf zwei verschiedene Instanzen beziehen, sind sie nicht identisch, aber ihre Inhalt sind gleich.

Daher enthält die Ausgabe vier Zeilen:

Str1 == str2

Str1 equals str2

Str3! = str4

Str3 equals str4

Answer 4

Sie sollten Folgendes verwenden String ist gleich um zwei Zeichenfolgen auf Gleichheit zu vergleichen, nicht der Operator ==, der nur die Referenzen vergleicht.

Answer 5

Es funktioniert auch, wenn Sie intern() auf die Zeichenkette, bevor sie in das Array eingefügt wird. Internierte Strings sind referenz-gleich ( == ) dann und nur dann, wenn sie wertgleich sind ( 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");    
}