Detaillierte Erklärung des Unterschieds zwischen == und equal in Java

Dieser Artikel bietet Ihnen eine detaillierte Erklärung des Unterschieds zwischen == und equal in Java. Ich hoffe, dass er für Freunde in Not hilfreich ist.

Der Unterschied zwischen == und equal in Java, ich habe das Gefühl, dass nur wenige Leute ihn völlig richtig sagen können.

Eine häufige falsche Antwort ist: == Basistypen vergleichen, ob die Werte gleich sind, Referenztypen vergleichen, ob die Referenzen gleich sind, und gleich vergleicht, ob die Werte gleich sind.

Warum es falsch ist, erfahren Sie, nachdem Sie die Erklärung dieses Artikels zu == und equal gelesen haben.

1. == Interpretation

Die Auswirkungen von == auf Grundtypen und Referenztypen sind wie folgt unterschiedlich:

Grundtypen: Die Vergleich ist, ob die Werte gleich sind; Referenztyp: Der Vergleich ist, ob die Referenzen gleich sind.

Codebeispiel:

String x = "string";
String y = "string";
String z = new String("string");
System.out.println(x==y); // true
System.out.println(x==z); // false
System.out.println(x.equals(y)); // true
System.out.println(x.equals(z)); // true

Codeinterpretation: Weil x und y auf dieselbe Referenz, also ist = = auch wahr, und die neue String()-Methode wird umgeschrieben, um Speicherplatz freizugeben, sodass das Ergebnis von == falsch ist und gleich immer Werte vergleicht, sodass alle Ergebnisse wahr sind.

2. Die Interpretation von equal

equals ist im Wesentlichen ==, mit der Ausnahme, dass String und Integer die Methode equal überschreiben und sie in einen Wertevergleich umwandeln. Schauen Sie sich zum Verständnis einfach den folgenden Code an.

Schauen wir uns zunächst an, wie equal standardmäßig Objekte mit demselben Wert vergleicht. Der Code lautet wie folgt:

class Cat {
    public Cat(String name) {
        this.name = name;
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Cat c1 = new Cat("王磊");
Cat c2 = new Cat("王磊");
System.out.println(c1.equals(c2)); // false

Das Ausgabeergebnis übertrifft unsere Erwartungen, es ist falsch? Was ist los? Sie werden es wissen, nachdem Sie den Quellcode von equal gelesen haben. Der Quellcode lautet wie folgt:

public boolean equals(Object obj) {
        return (this == obj);
}

Es stellt sich heraus, dass equal im Wesentlichen == ist.

Die Frage ist, warum zwei String-Objekte mit demselben Wert true zurückgeben? Der Code lautet wie folgt:

String s1 = new String("老王");
String s2 = new String("老王");
System.out.println(s1.equals(s2)); // true

Wenn wir die Equals-Methode von String eingeben, finden wir die Antwort. Der Code lautet wie folgt:

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

Es stellt sich heraus, dass String die Equals überschreibt Methode von Object und ändert den Referenzvergleich. Es wird ein Wertevergleich.

3. Zusammenfassung

Im Allgemeinen ist == ein Wertvergleich für Basistypen und für Referenztypen eine Referenz; und entspricht in diesem Fall den Standardwerten Es handelt sich um einen Referenzvergleich, aber viele Klassen haben die Methode „equals“ wie String, Integer usw. überschrieben und sie in einen Wertevergleich umgewandelt. Unter normalen Umständen vergleicht „equals“ also, ob die Werte gleich sind.

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung des Unterschieds zwischen == und equal in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!