Jaka jest różnica między = = A equals () w Javie?

W odniesieniu do klasy String:

Metoda equals () porównuje "wartość" wewnątrz instancji łańcuchowych (na stercie) niezależnie od tego, czy oba odwołania do obiektu odnoszą się do tej samej instancji łańcuchowej, czy nie. Jeśli dowolne dwa odniesienia do obiektów typu String odnoszą się do tej samej instancji String, to świetnie! Jeśli dwa odniesienia do obiektów odnoszą się do dwóch różnych instancji łańcuchowych .. to bez różnicy. Jego "wartość" (czyli zawartość tablicy znaków) wewnątrz każdego łańcucha przykład, który jest porównywany.

Z drugiej strony, operator "==" porównuje wartość dwóch odniesień do obiektów , aby sprawdzić, czy odnoszą się one do tej samej instancji String. Jeśli wartość obu obiektów odwołuje się "Referer to" do tej samej instancji łańcuchowej, to wynikiem wyrażenia logicznego będzie "true"..duh. Jeśli natomiast wartość obu obiektów referuje "Referer to" różne instancje łańcuchowe (nawet jeśli obie instancje łańcuchowe mają identyczne "wartości", czyli zawartość tablic znakowych każdej instancji łańcuchowej jest taka sama) wynikiem wyrażenia boolowskiego będzie "false".

Jak z każdym wyjaśnieniem, niech się pogrąży.

Mam nadzieję, że to trochę wyjaśni.

Istnieją niewielkie różnice w zależności od tego, czy mówimy o "prymitywach" czy o "typach obiektów"; to samo można powiedzieć, jeśli mówimy o członach "static" lub "non-static"; można również mieszać wszystkie powyższe...

Oto przykład (możesz go uruchomić):

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

}

Można porównać objaśnienia dla "= = "(Operator równości) i".równa(...) "(metoda w Javie.lang.Klasa obiektu) poprzez te linki:

• ==: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html
• .równa(...): http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals (java. Lang. Object)

Różnica między = = i equals myliła mnie przez jakiś czas, dopóki nie postanowiłem się temu bliżej przyjrzeć. Wiele z nich mówi, że do porównywania łańcuchów należy używać equals, a nie ==. Mam nadzieję, że w tej odpowiedzi będę w stanie powiedzieć różnicę.

Najlepszym sposobem na odpowiedź na to pytanie będzie zadanie sobie kilku pytań. Zacznijmy więc:

Jaki jest wynik dla poniższego programu:

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

Jeśli powiesz,

false
true

Powiem jesteś racja ale dlaczego to powiedziałeś ? a jeśli powiesz, że wyjście jest,

true
false

Powiem, że jesteś w błędzie ale nadal zapytam, dlaczego uważasz, że to słuszne?

Ok, spróbujmy odpowiedzieć na to:

Jaki jest wynik dla poniższego programu:

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

Teraz, jeśli powiesz,

false
true

Powiem, że jesteś w błędzie ale dlaczego teraz jest źle ? poprawne wyjście dla tego programu is

true
false

Proszę porównać powyższy program i spróbować go przemyśleć.

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

Czy możesz po prostu spróbować pomyśleć o wyjściu ostatnich trzech linii w powyższym kodzie: dla mnie ideone wydrukował to ( możesz sprawdzić kod tutaj):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

Mimo że wszystkie zmienne łańcuchowe-mango, mango2 i mango3 - mają tę samą wartość, którą jest "mango", identityHashCode() nadal nie jest taka sama dla wszystkich.

Teraz spróbuj odkomentować tę linię // mango2 = "mang"; i uruchom ją ponownie Tym razem zobaczysz, że wszystkie trzy identityHashCode() są różne. Hmm to jest pomocna podpowiedź

Wiemy, że jeśli hashcode(x)=N i hashcode(y)=N => x is equal to y

Nie jestem pewien, jak działa java wewnętrznie, ale zakładam, że tak się stało, gdy powiedziałem:]}

mango = "mango";

Java stworzyła łańcuch "mango", który był wskazywany(odwoływany) przez zmienną mango coś takiego

mango ----> "mango"

Teraz w następnej linijce, kiedy powiedziałem:

mango2 = "mango";

Rzeczywiście użył tego samego ciągu "mango" który wygląda mniej więcej tak

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

Zarówno mango, jak i mango2 wskazują na to samo odniesienie Teraz kiedy powiedziałem

mango3 = new String("mango")

Faktycznie stworzył zupełnie nowy reference (string) dla "mango". który wygląda mniej więcej tak,

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

mango3 ------> "mango"

I dlatego kiedy podaję wartości dla mango == mango2, to podaję true. i kiedy wystawiam wartość dla mango3 == mango2, to wystawiam false (nawet gdy wartości były takie same).

I kiedy nie widzisz linii // mango2 = "mang"; W rzeczywistości stworzył ciąg znaków "mang", który zmienił nasz wykres w następujący sposób: {]}

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

Dlatego identityHashCode nie jest taki sam dla wszystkich.

The == operator sprawdza, czy dwie zmienne mają te same odniesienia (aka wskaźnik do adresu pamięci) .

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)

Natomiast metoda equals () sprawdza, czy dwie zmienne odnoszą się do obiektów które mają ten sam stan (wartości) .

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

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

Będziesz musiał nadpisać funkcję equals (wraz z innymi), aby użyć tego z niestandardowymi klasami.

Metoda equals porównuje obiekty.

Operator binarny == porównuje adresy pamięci.

Both = = and .equals () odnosi się do tego samego obiektu, jeśli nie nadpisujesz.equals ().

To twoje życzenie, co chcesz zrobić po obejściu .equals (). Możesz porównać stan wywołującego obiekt ze stanem przekazanym w obiekcie lub po prostu wywołać super.equals ()

 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

== jest operatorem i equals() jest metodą .

Są zwykle używane do porównywania typów , a zatem == jest używany do porównywania adresów pamięci, a Metoda equals() do porównywania obiektów .

Pamiętaj, że {[2] } musi być zaimplementowana przez klasę, którą próbujesz porównać. W przeciwnym razie, nie ma zbyt wiele punktu; Wersja metody dla klasy Object robi to samo, co operacja porównania: Object#równa się .

Jedyny raz, kiedy naprawdę chcesz użyć operatora porównania dla obiektów, to wen porównujesz liczby. Dzieje się tak dlatego, że istnieje tylko jedna instancja wartości Enum na raz. Na przykład, biorąc pod uwagę enum

enum FooEnum {A, B, C}

Będziesz nigdy nie ma więcej niż jednej instancji A na raz, a to samo dla B i C. Oznacza to, że możesz napisać metodę w ten sposób:

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

I nie będziesz miał żadnych problemów.

Kiedy oceniasz kod, jest bardzo jasne, że ( = = ) porównuje według adresu pamięci, podczas gdy equals(Object o) porównuje hashCode() instancji. Dlatego mówi się, że nie należy łamać umowy pomiędzy equals() i hashCode (), jeśli później nie napotkasz niespodzianek.

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

Główna różnica pomiędzy = = i equals() wynosi

1) = = jest używany do porównywania prymitywów.

Na przykład:

        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() jest używane do porównywania obiektów. Na przykład:

        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

Oto ogólna zasada różnicy między relational operator == oraz the method .equals().

object1 == object2 porównuje, jeśli obiekty, do których odnoszą się obiekty object1 i object2 odnoszą się do t, to samo miejsce pamięci w stercie.

object1.equals(object2) porównuje wartości object1 i object2 niezależnie od tego, gdzie znajdują się w pamięci.

Można to dobrze zademonstrować za pomocą ciągu

Scenariusz 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 

Scenariusz 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

To porównanie łańcuchów może być użyte jako podstawa do porównywania innych typów obiektów.

Na przykład, jeśli mam klasę Person, muszę zdefiniować kryteria, na podstawie których porównam dwie osoby. Załóżmy, że ta klasa osoby ma zmienne instancji wzrostu i wagi.

Więc tworzenie obiektów person person1 and person2 i porównywanie tych dwóch za pomocą .equals() muszę nadpisać metodę equals osoby Klasa do zdefiniowania na podstawie zmiennych instancji (wysokości lub wagi) porównania.

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

Dla ułatwienia uogólnienia porównania obiektów tej osoby, stworzyłem następującą klasę testową. eksperymentowanie z tymi pojęciami ujawni mnóstwo faktów.

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

}

Wynik wykonania tej klasy to:

is person1 == person2 ? false
is person2 == person3 ? true
is person2.equals(person3) ? true
is person2.equals(person4) ? true
is person2.equals(person4) ? false

Zauważ również, że .equals() zwykle zawiera == do testowania, ponieważ jest to pierwsza rzecz, którą chcesz przetestować, jeśli chcesz sprawdzić, czy dwa obiekty są sobie równe.

I == rzeczywiście patrzy na wartości dla typów prymitywnych, dla obiektów sprawdza referencję.

== operator zawsze porównuje referencję. Ale w przypadku

Metoda Equals ()

To zależy od implementacji jeśli mamy nadpisaną metodę, niż porównuje obiekt na podstawie implementacji podanej w nadpisanej metodzie.

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

W powyższym kodzie zarówno obj, jak i obj1 obiekt zawiera te same dane, ale odniesienie nie jest takie samo, więc jest równe return false I = = also. ale jeśli overridden równa się method than

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

Know check out it will return true i false dla tego samego przypadku tylko my overridden

Równa się metoda .

Porównuje obiekt na podstawie zawartości (id) obiektu

Ale = =

Wciąż porównuje odniesienia do obiektu.

== może być używany w wielu typach obiektów, ale możesz używać Object.equals dla dowolnego typu, zwłaszcza ciągów znaków i znaczników Map Google.

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

    }
  }

----Wyjście----- prawda fałsz true

Warto dodać, że dla obiektów wrapper dla typów prymitywnych - tj. Int, Long, Double - = = zwróci true, jeśli obie wartości są równe.

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

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

Dla kontrastu, umieszczenie powyższych dwóch długich w dwóch oddzielnych Arraylistach, equals widzi je jako takie same, ale = = nie.

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

Ponieważ Java nie obsługuje przeciążania operatorów, == zachowuje się identycznie dla każdego obiektu ale {[2] } jest metodą, która może być nadpisana w Java i logika porównywania obiektów mogą być zmieniane w zależności od działalności Zasady.

Główna różnica między == A równa w Javie jest taka, że "==" jest używany do porównywanie prymitywów podczas gdy metoda equals() jest zalecana do sprawdzenia równość obiektów.

Porównywanie łańcuchów jest powszechnym scenariuszem użycia zarówno metody ==, jak i equals(). od java.lang.Klasa String override jest równa metodzie, to zwraca true, jeśli dwa obiekty String zawierają tę samą zawartość, ale == będzie zwraca true tylko wtedy, gdy dwie referencje wskazują ten sam obiekt.

Oto przykład porównania dwóch łańcuchów w Javie pod kątem równości przy użyciu metody == i equals(), który rozwiąże pewne wątpliwości:

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

    }
    }

String pool (aka interning ) i Integer pool rozmycie różnicy dalej i może pozwolić na użycie {[3] } dla obiektów w niektórych przypadkach zamiast .equals

Np.:

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

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

Złożoność może cię zaskoczyć:

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

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

Radzę trzymać się z dala od takiej mikro-optymalizacji i zawsze używaj .equals dla obiekty, oraz == dla prymitywów:

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

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

W skrócie, odpowiedź brzmi "tak".

W języku Java operator == porównuje dwa obiekty, aby sprawdzić, czy wskazują na to samo miejsce pamięci; podczas gdy metoda .equals() porównuje oba obiekty, aby sprawdzić, czy mają tę samą wartość obiektu.

Zasadniczo, == porównuje, jeśli dwa obiekty mają to samo odniesienie na stercie, więc jeśli dwa odniesienia nie są połączone z tym samym obiektem, to porównanie będzie fałszywe.

equals() jest metodą dziedziczoną z Object klasy. Ta metoda domyślnie porównuje, jeśli dwa obiekty mają ten sam referece. Oznacza:

object1.equals(object2) object1 == object2

Jednakże, jeśli chcesz ustalić równość pomiędzy dwoma obiektami tej samej klasy, powinieneś nadpisać tę metodę. On bardzo ważne jest również nadpisanie metody hashCode(), Jeśli masz nadpisane equals().

Zaimplementować hashCode() przy ustalaniu równości jest częścią kontraktu Java Object. Jeśli pracujesz z kolekcjami i nie zaimplementowałeś hashCode(), mogą się zdarzyć dziwne złe rzeczy:

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 zostanie wydrukowany po wykonaniu poprzedniego kodu, jeśli nie zaimplementowano hashCode().

Jest to różnica pomiędzy tożsamością i równoważnością .

a == b oznacza to, że a i b są identyczne, czyli są symbolami dla tego samego obiektu w pamięci.

a.equals( b ) oznacza to, że są one równoważne , że są symbolami dla obiektów, które w pewnym sensie mają tę samą wartość - chociaż obiekty te mogą zajmować różne miejsca w pamięci.

Zauważ, że wraz z równoważnością pojawia się pytanie, Jak oceniać i porównywać obiekty do gry -- złożone obiekty mogą być uważane za równoważne w celach praktycznych, mimo że niektóre z ich treści różnią się. Z tożsamością nie ma takiego pytania.