it-swarm.com.de

Was ist der Unterschied zwischen == und equals () in Java?

Ich wollte klarstellen, ob ich das richtig verstanden habe:

  • == -> ist ein Referenzvergleich, d. h. beide Objekte zeigen auf denselben Speicherplatz
  • .equals() -> wertet den Vergleich von Werten in den Objekten aus

Bin ich in meinem Verständnis richtig?

537
brainydexter

Im Allgemeinen ist die Antwort auf Ihre Frage "Ja", aber ...

  • .equals(...) vergleicht nur das, was geschrieben wird, um zu vergleichen, nicht mehr und nicht weniger.
  • Wenn eine Klasse die equals-Methode nicht überschreibt, wird standardmäßig die equals(Object o)-Methode der nächstgelegenen übergeordneten Klasse verwendet, die diese Methode überschrieben hat. 
  • Wenn keine übergeordneten Klassen eine Überschreibung bereitgestellt haben, wird standardmäßig die Methode der obersten übergeordneten Klasse Object verwendet, sodass Sie die Object#equals(Object o)-Methode verwenden. Für die Objekt-API ist dies dasselbe wie für ==; es gibt also wahr wenn und nur wenn beide Variablen beziehen sich auf dasselbe Objekt, wenn ihre Referenzen gleich sind. Sie werden also auf Objektgleichheit und nicht auf funktionale Gleichheit prüfen.
  • Denken Sie immer daran, hashCode zu überschreiben, wenn Sie equals überschreiben, um den Vertrag nicht zu brechen. Gemäß der API muss das Ergebnis, das von der hashCode()-Methode für zwei Objekte must zurückgegeben wird, dasselbe sein, wenn ihre equals-Methode zeigt, dass sie gleichwertig sind. Das Gegenteil ist nicht notwendigerweise wahr. 

In Bezug auf die String-Klasse:

Die equals () Methode vergleicht den "Wert" in String-Instanzen (auf dem Heap), unabhängig davon, ob die beiden Objektverweise auf dieselbe String-Instanz verweisen oder nicht. Wenn zwei Objektverweise vom Typ String auf dieselbe String-Instanz verweisen, dann ist es großartig! Wenn sich die beiden Objektverweise auf zwei verschiedene String-Instanzen beziehen, ist dies nicht von Bedeutung. Es ist der "Wert" (dh der Inhalt des Zeichen-Arrays) in jeder String-Instanz, die verglichen wird.

Auf der anderen Seite vergleicht der "==" Operator den Wert von zwei Objektreferenzen, um zu sehen, ob sie sich auf dasselbe String-Instanz beziehen. Wenn der Wert beider Objektverweise auf dieselbe String-Instanz "verweist", wäre das Ergebnis des booleschen Ausdrucks "true" .. duh. Wenn sich der Wert der beiden Objektverweise dagegen "auf" verschiedene String-Instanzenbezieht, _ (obwohl beide String-Instanzen identische "Werte" haben), ist dies der Inhalt der Zeichenarrays jedes Strings Instanz sind die gleichen) Das Ergebnis des booleschen Ausdrucks wäre "false".

Wie bei jeder Erklärung, lassen Sie es einsinken.

Ich hoffe, das klärt die Sache ein wenig.

94

Es gibt einige kleine Unterschiede, je nachdem, ob Sie von "Grundelementen" oder "Objekttypen" sprechen. Das Gleiche kann gesagt werden, wenn Sie von "statischen" oder "nicht statischen" Mitgliedern sprechen. Sie können auch alle oben genannten ...

Hier ist ein Beispiel (Sie können es ausführen):

public final class MyEqualityTest
{
    public static void main( String args[] )
    {
        String s1 = new String( "Test" );
        String s2 = new String( "Test" );

        System.out.println( "\n1 - PRIMITIVES ");
        System.out.println( s1 == s2 ); // false
        System.out.println( s1.equals( s2 )); // true

        A a1 = new A();
        A a2 = new A();

        System.out.println( "\n2 - OBJECT TYPES / STATIC VARIABLE" );
        System.out.println( a1 == a2 ); // false
        System.out.println( a1.s == a2.s ); // true
        System.out.println( a1.s.equals( a2.s ) ); // true

        B b1 = new B();
        B b2 = new B();

        System.out.println( "\n3 - OBJECT TYPES / NON-STATIC VARIABLE" );
        System.out.println( b1 == b2 ); // false
        System.out.println( b1.getS() == b2.getS() ); // false
        System.out.println( b1.getS().equals( b2.getS() ) ); // true
    }
}

final class A
{
    // static
    public static String s;
    A()
    {
        this.s = new String( "aTest" );
    }
}

final class B
{
    private String s;
    B()
    {
        this.s = new String( "aTest" );
    }

    public String getS()
    {
        return s;
    }

}

Sie können die Erklärungen für "==" (Equality Operator) und ".equals (...)" (Methode in der Java.lang.Object-Klasse) über die folgenden Links vergleichen:

52
Almir Campos

Der Unterschied zwischen == und equals verwirrte mich für einige Zeit, bis ich beschloss, es mir genauer anzusehen. Viele von ihnen sagen, dass Sie zum Vergleichen von Zeichenketten equals und nicht == verwenden sollten. Ich hoffe auf diese Antwort kann ich den Unterschied sagen.

Der beste Weg, diese Frage zu beantworten, besteht darin, sich einige Fragen zu stellen. so lass uns anfangen:

Was ist die Ausgabe für das folgende Programm:

String mango = "mango";
String mango2 = "mango";
System.out.println(mango != mango2);
System.out.println(mango == mango2);

wenn du sagst, 

false
true

Ich werde sagen, dass Sie richtig sind, aber warum haben Sie das? Gesagt und wenn Sie sagen, dass die Ausgabe ist,

true
false

Ich werde sagen, dass Sie falsch sind, aber ich werde Sie trotzdem fragen, warum Sie denken, dass das richtig ist?

Ok, lassen Sie uns versuchen, diese Frage zu beantworten:

Was ist die Ausgabe für das folgende Programm:

String mango = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango3);
System.out.println(mango == mango3);

Nun, wenn Sie sagen,

false
true

Ich werde sagen, Sie sind falsch, aber warum ist es jetzt falsch? Die korrekte Ausgabe für dieses Programm ist

true
false

Bitte vergleichen Sie das obige Programm und versuchen Sie, darüber nachzudenken.

OK. Nun könnte dies helfen (bitte lesen Sie dies: geben Sie die Adresse des Objekts an - nicht möglich, aber wir können sie trotzdem verwenden.)

String mango = "mango";
String mango2 = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango2);
System.out.println(mango == mango2);
System.out.println(mango3 != mango2);
System.out.println(mango3 == mango2);
// mango2 = "mang";
System.out.println(mango+" "+ mango2);
System.out.println(mango != mango2);
System.out.println(mango == mango2);

System.out.println(System.identityHashCode(mango));
System.out.println(System.identityHashCode(mango2));
System.out.println(System.identityHashCode(mango3));

kannst du nur versuchen, über die Ausgabe der letzten drei Zeilen im obigen Code nachzudenken: Für mich hat ideone dies ausgedruckt ( du kannst den Code hier überprüfen ):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

Oh! Jetzt sehen Sie, dass identityHashCode (mango) gleich identityHashCode (mango2) ist. Aber es ist nicht gleich identityHashCode (mango3).

Obwohl alle Stringvariablen - Mango, Mango2 und Mango3 - den same - Wert haben, der "Mango" ist, ist identityHashCode() immer noch nicht für alle gleich.

Versuchen Sie nun, diese Zeile // mango2 = "mang"; auszukommentieren, und führen Sie sie erneut aus. Diesmal sehen Sie, dass alle drei identityHashCode() unterschiedlich sind. __

wir wissen, dass wenn hashcode(x)=N und hashcode(y)=N => x is equal to y

Ich bin nicht sicher, wie Java intern funktioniert, aber ich gehe davon aus, dass dies passiert ist, als ich sagte:

mango = "mango";

Java hat eine Zeichenfolge "mango" erstellt, auf die von der Variablen mango in gewisser Weise verwiesen wurde

mango ----> "mango"

Nun in der nächsten Zeile, als ich sagte:

mango2 = "mango";

Es hat tatsächlich den gleichen String "mango" wiederverwendet, der ungefähr so ​​aussieht

mango ----> "mango" <---- mango2

Sowohl die Mango als auch die Mango2 zeigen auf dieselbe Referenz 

mango3 = new String("mango")

Es wurde tatsächlich eine komplett neue Referenz (String) für "Mango" erstellt. was so aussieht,

mango -----> "mango" <------ mango2

mango3 ------> "mango"

und deshalb, wenn ich die Werte für mango == mango2 ausstelle, wird true ausgegeben. und wenn ich den Wert für mango3 == mango2 ausstelle, wurde false ausgegeben (auch wenn die Werte gleich waren).

und als Sie die Zeile // mango2 = "mang"; auskommentiert haben, wurde tatsächlich eine Zeichenfolge "mang" erstellt, die unser Diagramm so umwandelte:

mango ---->"mango"
mango2 ----> "mang"
mango3 -----> "mango"

Deshalb ist der identityHashCode nicht für alle gleich.

Ich hoffe, das hilft Ihnen, Jungs. Eigentlich wollte ich einen Testfall generieren, bei dem == fehlschlägt und equals () bestanden wird.

40
govindpatel

Der Operator == prüft, ob zwei Variablen die gleichen Referenzen haben (aka Zeiger auf eine Speicheradresse) .

String foo = new String("abc");
String bar = new String("abc");

if(foo==bar)
// False (The objects are not the same)

bar = foo;

if(foo==bar)
// True (Now the objects are the same)

Während die equals () - Methode prüft, ob sich zwei Variablen auf Objekte beziehen die den gleichen Zustand (Werte) haben.

String foo = new String("abc");
String bar = new String("abc");

if(foo.equals(bar))
// True (The objects are identical but not same)

Prost :-)

29
dheeran

Sie müssen die equals-Funktion (zusammen mit anderen) überschreiben, um dies mit benutzerdefinierten Klassen zu verwenden.

Die Methode equals vergleicht die Objekte.

Der ==-Binäroperator vergleicht Speicheradressen.

12
Andrew Carr

Sowohl == als auch .equals () beziehen sich auf dasselbe Objekt, wenn Sie .equals () nicht überschreiben. 

Es ist Ihr Wunsch, was Sie tun möchten, wenn Sie .equals () überschreiben. Sie können den Status des aufrufenden Objekts mit dem Status des übergebenen Objekts vergleichen oder einfach super.equals () aufrufen.

6
tintin

== ist ein Operator und equals() ist eine Methode.

Operatoren werden im Allgemeinen für Vergleiche mit dem Typ primitive verwendet. Daher wird == für den Vergleich von Speicheradressen und die Methode equals() für den Vergleich von objects verwendet. 

5
ayniam

Denken Sie daran, dass .equals(...) von der Klasse implementiert werden muss, die Sie zu vergleichen versuchen. Ansonsten gibt es keinen großen Punkt; Die Version der Methode für die Object-Klasse hat dieselbe Funktion wie die Vergleichsoperation: Object # equals .

Sie möchten den Vergleichsoperator nur für Objekte wirklich verwenden, wenn Sie Enums vergleichen. Dies liegt daran, dass jeweils nur eine Instanz eines Aufzählungswerts vorhanden ist. Zum Beispiel gegeben die Aufzählung

enum FooEnum {A, B, C}

Sie werden nie mehr als eine Instanz von A gleichzeitig haben, und dieselbe für B und C. Das bedeutet, dass Sie eine Methode tatsächlich so schreiben können:

public boolean compareFoos(FooEnum x, FooEnum y)
{
    return (x == y);
}

Und Sie werden keinerlei Probleme haben.

5
fruchtose
 String w1 ="Sarat";
 String w2 ="Sarat";
 String w3 = new String("Sarat");

 System.out.println(w1.hashCode());   //3254818
 System.out.println(w2.hashCode());   //3254818
 System.out.println(w3.hashCode());   //3254818

 System.out.println(System.identityHashCode(w1)); //prints 705927765
 System.out.println(System.identityHashCode(w2)); //prints 705927765
 System.out.println(System.identityHashCode(w3)); //prints 366712642


 if(w1==w2)   //  (705927765==705927765)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints true

 if(w2==w3)   //  (705927765==366712642)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints false


 if(w2.equals(w3))   //  (Content of 705927765== Content of 366712642)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints true
5
Sarat Chandra

Der Operator ==:

== ist ein relationaler Operator in Java, mit dem zwei Operanden verglichen werden. Es wird verwendet, um zu bestimmen, ob die beiden Operanden gleich sind oder nicht. Mit dem Operator == können Sie jeden primitiven Typ wie int, char, float und Booleans vergleichen. Nach dem Vergleich gibt der Operator == einen booleschen Wert zurück. Wenn die beiden Operanden gleich sind, gibt der Operator == einen wahren Wert zurück. Wenn die beiden Operanden jedoch nicht gleich sind, wird ein falscher Wert zurückgegeben. Wenn der Operator == mit Objekten verwendet wird, werden die beiden Objektverweise verglichen und es wird festgestellt, ob sie sich auf dieselbe Instanz beziehen.

Die .equals () -Methode

equals () ist eine in der String-Klasse verfügbare Methode, mit der zwei Zeichenfolgen verglichen und festgestellt werden, ob sie gleich sind. Diese Methode gibt einen booleschen Wert als Ergebnis des Vergleichs zurück. Wenn die beiden Zeichenfolgen dieselben Zeichen in derselben Reihenfolge enthalten, gibt die equals () -Methode true zurück. Andernfalls wird ein falscher Wert zurückgegeben.

Der Hauptunterschied zwischen == und equals () ist

1) == wird zum Vergleichen von Grundelementen verwendet.

Zum Beispiel : 

        String string1 = "Ravi";
        String string2 = "Ravi";
        String string3 = new String("Ravi");
        String string4 = new String("Prakash");

        System.out.println(string1 == string2); // true because same reference in string pool
        System.out.println(string1 == string3); // false

2) equals () wird zum Vergleichen von Objekten verwendet .. __ Beispiel:

        System.out.println(string1.equals(string2)); // true equals() comparison of values in the objects
        System.out.println(string1.equals(string3)); // true
        System.out.println(string1.equals(string4)); // false
3
Ravi Patel

Beachten Sie auch, dass .equals() normalerweise == zum Testen enthält, da dies das erste ist, auf das Sie testen möchten, ob Sie testen möchten, ob zwei Objekte gleich sind. 

Und == betrachtet tatsächlich Werte für primitive Typen, für Objekte überprüft sie die Referenz.

3
bfs

Wenn Sie den Code auswerten, ist es sehr klar, dass (==) die Speicheradresse vergleicht, während equals (Object o) hashCode () der Instanzen vergleicht. Deshalb wird gesagt, brechen Sie den Vertrag zwischen equals () und hashCode () nicht ab, wenn Sie später nicht auf Überraschungen stoßen. 

    String s1 = new String("ALi");
    String s2 = new String("Veli");
    String s3 = new String("ALi");

    System.out.println(s1.hashCode());
    System.out.println(s2.hashCode());
    System.out.println(s3.hashCode());


    System.out.println("(s1==s2):" + (s1 == s2));
    System.out.println("(s1==s3):" + (s1 == s3));


    System.out.println("s1.equals(s2):" + (s1.equals(s2)));
    System.out.println("s1.equal(s3):" + (s1.equals(s3)));


    /*Output 
    96670     
    3615852
    96670
    (s1==s2):false
    (s1==s3):false
    s1.equals(s2):false
    s1.equal(s3):true
    */
3
huseyin
public class StringPool {

public static void main(String[] args) {

    String s1 = "Cat";// will create reference in string pool of heap memory
    String s2 = "Cat";
    String s3 = new String("Cat");//will create a object in heap memory

    // Using == will give us true because same reference in string pool

    if (s1 == s2) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    // Using == with reference and Object will give us False

    if (s1 == s3) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    // Using .equals method which refers to value

    if (s1.equals(s3)) {
        System.out.println("true");
    } else {
        System.out.println("False");
    }

    }
  }

----Ausgabe----- wahr falsch wahr

2
Aamir Meman

Hier ist ein allgemeiner Maßstab für den Unterschied zwischen relational operator == und the method .equals().

_object1 == object2_ vergleicht, ob die von object1 und object2 referenzierten Objekte auf t denselben Speicherort in Heap verweisen.

object1.equals(object2) vergleicht die Werte von object1 und object2 unabhängig davon, wo sie sich im Speicher befinden.

Dies kann mit String gut demonstriert werden

Szenario 1

_ public class Conditionals {

    public static void main(String[] args) {
       String str1 = "Hello";
       String str2 = new String("Hello");
       System.out.println("is str1 == str2 ? " + (str1 == str2 ));
       System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
    }

 }



The result is
      is str1 == str2 ? false
      is str1.equals(str2) ? true 
_

Szenario 2

_public class Conditionals {

    public static void main(String[] args) {
       String str1 = "Hello";
       String str2 = "Hello";
       System.out.println("is str1 == str2 ? " + (str1 == str2 ));
       System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
    }

}

The result is 
  is str1 == str2 ? true
  is str1.equals(str2) ? true
_

Dieser Zeichenfolgenvergleich kann als Grundlage für den Vergleich anderer Objekttypen verwendet werden.

Wenn ich zum Beispiel eine Personenklasse habe, muss ich die Kriterienbasis definieren, auf der ich zwei Personen vergleiche. Nehmen wir an, diese Personenklasse hat Instanzvariablen von Größe und Gewicht.

Wenn Sie also Personenobjekte _person1 and person2_ erstellen und diese mit der Funktion .equals() vergleichen möchten, müssen Sie die Methode equals der Personenklasse überschreiben, um zu definieren, anhand welcher Instanzvariablen (Höhe oder Gewicht) der Vergleich durchgeführt werden soll Sein.

Die == operator will still return results based on the memory location of the two objects(person1 and person2).

Um diesen Personenobjektvergleich zu verallgemeinern, habe ich die folgende Testklasse erstellt. Das Experimentieren mit diesen Konzepten wird Unmengen von Fakten enthüllen.

_package com.tadtab.CS5044;

public class Person {

private double height;
private double weight;

public double getHeight() {
    return height;
}

public void setHeight(double height) {
    this.height = height;
}

public double getWeight() {
    return weight;
}

public void setWeight(double weight) {
    this.weight = weight;
}


@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    long temp;
    temp = Double.doubleToLongBits(height);
    result = prime * result + (int) (temp ^ (temp >>> 32));
    return result;
}

@Override
/**
 * This method uses the height as a means of comparing person objects.
 * NOTE: weight is not part of the comparison criteria
 */
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Person other = (Person) obj;
    if (Double.doubleToLongBits(height) != Double.doubleToLongBits(other.height))
        return false;
    return true;
}

public static void main(String[] args) {

    Person person1 = new Person();
    person1.setHeight(5.50);
    person1.setWeight(140.00);

    Person person2 = new Person();
    person2.setHeight(5.70);
    person2.setWeight(160.00);

    Person person3 = new Person();
    person3 = person2;

    Person person4 = new Person();
    person4.setHeight(5.70);

    Person person5 = new Person();
    person5.setWeight(160.00);

    System.out.println("is person1 == person2 ? " + (person1 == person2)); // false;
    System.out.println("is person2 == person3 ? " + (person2 == person3)); // true 
    //this is because perosn3 and person to refer to the one person object in memory. They are aliases;
    System.out.println("is person2.equals(person3) ? " + (person2.equals(person3))); // true;

    System.out.println("is person2.equals(person4) ? " + (person2.equals(person4))); // true;

    // even if the person2 and person5 have the same weight, they are not equal.
    // it is because their height is different
    System.out.println("is person2.equals(person4) ? " + (person2.equals(person5))); // false;
}

}
_

Ergebnis dieser Klassenausführung ist:

_is person1 == person2 ? false
is person2 == person3 ? true
is person2.equals(person3) ? true
is person2.equals(person4) ? true
is person2.equals(person4) ? false
_
2
tadtab

Es kann sinnvoll sein, Folgendes hinzuzufügen: für Wrapper-Objekte für primitive Typen - d. H. Int, Long, Double - == wird true zurückgeben, wenn die beiden Werte gleich sind.

Long a = 10L;
Long b = 10L;

if (a == b) {
    System.out.println("Wrapped primitives behave like values");
}

Wenn Sie dagegen die beiden obigen Longs in zwei separate ArrayLists einfügen, werden sie von gleich als gleich angesehen, aber == nicht.

ArrayList<Long> c = new ArrayList<>();
ArrayList<Long> d = new ArrayList<>();

c.add(a);
d.add(b);
if (c == d) System.out.println("No way!");
if (c.equals(d)) System.out.println("Yes, this is true.");
2
Elroch

== kann in vielen Objekttypen verwendet werden, Sie können Object.equals jedoch für jeden Typ verwenden, insbesondere für Strings und Google Map-Markierungen.

2
Dearwolves

== Der Operator wird immer verglichen. Aber im Falle von 

methode equals ()

es hängt von der Implementierung ab, ob wir die gleich überschriebene Methode überschreiben, als sie das Objekt mit den grundlegenden Elementen der Implementierung vergleicht, die in der überschriebenen Methode angegeben sind. 

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//fasle
      obj==obj1 // fasle
    }
 }

obiges Objekt und obj1-Objekt enthalten im obigen Code die gleichen Daten, aber der Verweis ist nicht derselbe. Daher gibt equals false zurück und == auch ..__

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }
    public boolean equals(Object obj)
    {
       A a1=(A)obj;
      return this.id==a1.id;
    }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//true
      obj==obj1 // fasle
    }
 }

wenn Sie herausfinden, wird es wahr und falsch für denselben Fall zurückgegeben, nur wenn wir es überschrieben haben 

entspricht der Methode.

es vergleicht das Objekt mit dem Grundinhalt (ID) des Objekts

aber ==

vergleichen Sie noch Referenzen von Objekt.

2
Sachin Jadhav

Da Java keine Operatorüberladung unterstützt, verhält sich == für jedes Objekt identisch., Aber die Methode equals () ist eine Methode, die in ___ überschrieben werden kann. Java und Logik zum Vergleichen von Objekten können basierend auf den Geschäftsregeln von .

Der Hauptunterschied zwischen == und equals in Java besteht darin, dass "==" verwendet wird, um Primitive zu vergleichen, während die equals () -Methode empfohlen wird, um die Gleichheit von Objekten zu überprüfen.

Der Zeichenfolgenvergleich ist ein übliches Szenario für die Verwendung der Methode == und der Methode equals. Da die Java.lang.String-Klasse die equals-Methode überschreibt, gibt It True zurück, wenn zwei String-Objekte denselben Inhalt enthalten, aber == wird Nur true zurück, wenn zwei Referenzen auf dasselbe Objekt zeigen.

Hier ist ein Beispiel der Vergleich zweier Strings in Java zur Gleichheit mit der Methode == und equals (), wodurch einige Zweifel ausgeräumt werden:

public class TEstT{

    public static void main(String[] args) {

String text1 = new String("Apple");
String text2 = new String("Apple");

//since two strings are different object result should be false
boolean result = text1 == text2;
System.out.println("Comparing two strings with == operator: " + result);

//since strings contains same content , equals() should return true
result = text1.equals(text2);
System.out.println("Comparing two Strings with same content using equals method: " + result);

text2 = text1;
//since both text2 and text1d reference variable are pointing to same object
//"==" should return true
result = (text1 == text2);
System.out.println("Comparing two reference pointing to same String with == operator: " + result);

}
}
0
Mike Clark

Kurz gesagt, die Antwort lautet "Ja".

In Java vergleicht der ==-Operator die beiden Objekte, um festzustellen, ob sie auf denselben Speicherort zeigen. Die .equals()-Methode vergleicht tatsächlich die beiden Objekte, um zu sehen, ob sie denselben Objektwert haben.

0
JamesOstmann

Grundsätzlich vergleicht ==, wenn zwei Objekte auf dem Heap die gleiche Referenz haben. Wenn also nicht zwei Referenzen mit demselben Objekt verknüpft sind, ist dieser Vergleich falsch.

equals() ist eine vonObjectclass vererbte Methode. Diese Methode vergleicht standardmäßig, wenn zwei Objekte die gleiche Referenz haben. Es bedeutet:

object1.equals(object2) <=> object1 == object2

Wenn Sie jedoch die Gleichheit zwischen zwei Objekten derselben Klasse herstellen möchten, sollten Sie diese Methode überschreiben. Es ist auch sehr wichtig, die Methode hashCode() zu überschreiben, wenn Sie equals() überschreiben.

Implementieren Sie hashCode(), wenn Sie die Gleichheit festlegen, ist Teil des Java-Objektvertrags. Wenn Sie mit Sammlungen arbeiten und hashCode() nicht implementiert haben, können seltsame schlechte Dinge passieren:

HashMap<Cat, String> cats = new HashMap<>();
Cat cat = new Cat("molly");
cats.put(cat, "This is a cool cat");
System.out.println(cats.get(new Cat("molly"));

null wird nach der Ausführung des vorherigen Codes gedruckt, wenn Sie hashCode() nicht implementiert haben.

0
lmiguelvargasf

Der String-Pool (aka Interning ) und Integer-Pool verwischen den Unterschied weiter und ermöglichen möglicherweise die Verwendung von == für Objekte in einigen Fällen anstelle von .equals

Dies kann zu einer höheren Leistung (?) Führen, jedoch auf Kosten einer größeren Komplexität.

Z.B.:

assert "ab" == "a" + "b";

Integer i = 1;
Integer j = i;
assert i == j;

Kompromiss zwischen Komplexität: Folgendes kann Sie überraschen:

assert new String("a") != new String("a");

Integer i = 128;
Integer j = 128;
assert i != j;

Ich empfehle Ihnen, sich von einer solchen Mikrooptimierung fernzuhalten, und immer benutze .equals für Objekte und == für Grundelemente:

assert (new String("a")).equals(new String("a"));

Integer i = 128;
Integer j = 128;
assert i.equals(j);