Apa perbedaan antara == dan equals () di Java?

Saya ingin mengklarifikasi jika saya memahami ini dengan benar:

• == adalah perbandingan referensi, yaitu kedua objek menunjuk ke lokasi memori yang sama
• .equals() mengevaluasi perbandingan nilai dalam objek

Secara umum, jawaban untuk pertanyaan Anda adalah "ya", tetapi ...

• .equals(...) hanya akan membandingkan apa yang ditulis untuk membandingkan, tidak lebih, tidak kurang.
• Jika kelas tidak menimpa metode equals, maka default ke equals(Object o)metode kelas induk terdekat yang telah menimpa metode ini.
• Jika tidak ada kelas induk yang menyediakan override, maka defaultnya adalah metode dari kelas induk terakhir, Obyek, dan Anda ditinggalkan dengan Object#equals(Object o)metode tersebut. Per Object API ini sama dengan ==; yaitu, mengembalikan true jika dan hanya jika kedua variabel merujuk ke objek yang sama, jika referensi mereka adalah satu dan sama. Dengan demikian Anda akan menguji kesetaraan objek dan bukan kesetaraan fungsional .
• Selalu ingat untuk mengganti hashCodejika Anda mengganti equalsagar tidak "melanggar kontrak". Sesuai API, hasil yang dikembalikan dari hashCode()metode untuk dua objek harus sama jika equalsmetode mereka menunjukkan bahwa mereka setara. Kebalikannya belum tentu benar.

Sehubungan dengan kelas String:

Equals () metode membandingkan "nilai" dalam contoh String (di heap) terlepas jika dua referensi objek mengacu String contoh yang sama atau tidak. Jika ada dua objek referensi dari tipe String merujuk ke instance String yang sama maka hebat! Jika dua referensi objek merujuk pada dua instance String yang berbeda .. itu tidak membuat perbedaan. Ini adalah "nilai" (yaitu: isi dari array karakter) di dalam setiap instance String yang sedang dibandingkan.

Di sisi lain, operator "==" membandingkan nilai dua referensi objek untuk melihat apakah mereka merujuk ke instance String yang sama . Jika nilai kedua referensi objek "merujuk ke" contoh String yang sama maka hasil dari ekspresi boolean akan menjadi "benar" .. ya. Jika, di sisi lain, nilai dari kedua referensi objek "merujuk ke" instance String yang berbeda (meskipun kedua instance String memiliki "nilai" yang identik, yaitu, isi array karakter dari setiap instance String adalah sama) hasil dari ekspresi boolean akan menjadi "salah".

Seperti halnya penjelasan apa pun, biarkan masuk.

Saya harap ini membersihkan sedikit.

Ada beberapa perbedaan kecil tergantung apakah Anda berbicara tentang "primitif" atau "Jenis Objek"; hal yang sama dapat dikatakan jika Anda berbicara tentang anggota "statis" atau "non-statis"; Anda juga dapat mencampur semua hal di atas ...

Berikut ini sebuah contoh (Anda dapat menjalankannya):

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

}

Anda dapat membandingkan penjelasan untuk "==" (Operator Kesetaraan) dan ".equals (...)" (metode di kelas java.lang.Object) melalui tautan ini:

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

Perbedaan antara == dan yang sama membingungkan saya untuk beberapa saat sampai saya memutuskan untuk melihatnya lebih dekat. Banyak dari mereka mengatakan bahwa untuk membandingkan string yang harus Anda gunakan equalsdan tidak ==. Semoga dalam jawaban ini saya akan bisa mengatakan perbedaannya.

Cara terbaik untuk menjawab pertanyaan ini adalah dengan mengajukan beberapa pertanyaan kepada diri Anda sendiri. jadi ayo mulai:

Apa output untuk program di bawah ini:

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

jika Anda mengatakan,

false
true

Saya akan mengatakan Anda benar tetapi mengapa Anda mengatakan itu ? dan Jika Anda mengatakan outputnya adalah,

true
false

Saya akan mengatakan Anda salah tetapi saya masih akan bertanya, mengapa Anda berpikir itu benar?

Ok, mari kita coba jawab yang ini:

Apa output untuk program di bawah ini:

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

Sekarang, jika Anda berkata,

false
true

Saya akan mengatakan Anda salah, tetapi mengapa sekarang salah ? output yang benar untuk program ini adalah

true
false

Silakan bandingkan program di atas dan coba pikirkan.

Baik. Sekarang ini mungkin membantu (harap baca ini: cetak alamat objek - tidak mungkin tetapi kita masih bisa menggunakannya.)

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

dapatkah Anda mencoba memikirkan output dari tiga baris terakhir dalam kode di atas: untuk saya ideone mencetaknya ( Anda dapat memeriksa kode di sini ):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

Oh! Sekarang Anda melihat identityHashCode (mangga) sama dengan identityHashCode (mangga2) Tapi itu tidak sama dengan identityHashCode (mangga3)

Meskipun semua variabel string - mangga, mangga 2 dan mangga 3 - memiliki nilai yang sama , yaitu "mangga", identityHashCode()masih belum sama untuk semua.

Sekarang coba batalkan komentar pada baris ini // mango2 = "mang";dan jalankan lagi kali ini Anda akan melihat ketiganya identityHashCode()berbeda. Hmm itu petunjuk yang bermanfaat

kita tahu bahwa jika hashcode(x)=Ndan hashcode(y)=N=>x is equal to y

Saya tidak yakin bagaimana java bekerja secara internal tetapi saya menganggap ini adalah apa yang terjadi ketika saya berkata:

mango = "mango";

java membuat string "mango"yang ditunjuk (direferensikan) oleh variabel mangoseperti ini

mango ----> "mango"

Sekarang di baris berikutnya ketika saya berkata:

mango2 = "mango";

Ini benar-benar menggunakan kembali string "mango"yang sama yang terlihat seperti ini

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

Baik mangga dan mangga menunjuk ke referensi yang sama Sekarang ketika saya berkata

mango3 = new String("mango")

Ini sebenarnya menciptakan referensi (string) yang sama sekali baru untuk "mangga". yang terlihat seperti ini,

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

mango3 ------> "mango"

dan itulah sebabnya ketika saya mengeluarkan nilai-nilai untuk mango == mango2, itu dikeluarkan true. dan ketika saya mengeluarkan nilai untuk mango3 == mango2, itu mengeluarkan false(bahkan ketika nilainya sama).

dan ketika Anda membatalkan komentar baris // mango2 = "mang"; itu benar-benar menciptakan string "mang" yang mengubah grafik kita seperti ini:

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

Inilah sebabnya mengapa identityHashCode tidak sama untuk semua.

Semoga ini bisa membantu kalian. Sebenarnya, saya ingin membuat test case di mana == gagal dan sama dengan () lulus. Silakan berkomentar dan beri tahu saya jika saya salah.

The == tes Operator apakah dua variabel memiliki referensi yang sama (alias pointer ke alamat memori) .

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)

Sedangkan metode equals () menguji apakah dua variabel merujuk ke objek yang memiliki status (nilai) yang sama .

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

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

Bersulang :-)

Anda harus mengganti fungsi equals (bersama dengan yang lain) untuk menggunakan ini dengan kelas kustom.

Metode equals membandingkan objek.

The ==operator biner membandingkan alamat memori.

Baik == dan .equals () merujuk ke objek yang sama jika Anda tidak menimpa .equals ().

Ini keinginan Anda apa yang ingin Anda lakukan setelah Anda menimpa .equals (). Anda dapat membandingkan status objek pemanggilan dengan status objek yang diteruskan atau Anda bisa memanggil super.equals ()

==adalah operator dan equals()merupakan metode .

Operator umumnya digunakan untuk perbandingan tipe primitif dan dengan demikian ==digunakan untuk perbandingan alamat memori dan equals()metode digunakan untuk membandingkan objek .

 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

Ingatlah bahwa .equals(...)itu harus diimplementasikan oleh kelas yang Anda coba bandingkan. Kalau tidak, tidak ada gunanya; versi metode untuk kelas Object melakukan hal yang sama dengan operasi perbandingan: Object # equals .

Satu-satunya waktu Anda benar-benar ingin menggunakan operator pembanding untuk objek adalah ketika Anda membandingkan Enums. Ini karena hanya ada satu instance dari nilai Enum pada suatu waktu. Misalnya, diberi enum

enum FooEnum {A, B, C}

Anda tidak akan pernah memiliki lebih dari satu contoh Asekaligus, dan hal yang sama untuk Bdan C. Ini berarti Anda benar-benar dapat menulis metode seperti ini:

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

Dan Anda tidak akan memiliki masalah apa pun.

Ketika Anda mengevaluasi kode, sangat jelas bahwa (==) membandingkan menurut alamat memori, sementara sama dengan (Objek o) membandingkan kode hash () dari instance. Itu sebabnya dikatakan jangan putus kontrak antara equals () dan hashCode () jika Anda tidak menghadapi kejutan nanti.

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

Berikut adalah aturan umum untuk perbedaan antara relational operator ==dan the method .equals().

object1 == object2membandingkan jika objek yang dirujuk oleh object1 dan object2 merujuk ke lokasi memori yang sama di Heap .

object1.equals(object2)membandingkan nilai-nilai dari object1 dan object2 terlepas dari di mana mereka berada di memori .

Ini dapat ditunjukkan dengan baik menggunakan String

skenario 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 

Skenario 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

Perbandingan string ini dapat digunakan sebagai dasar untuk membandingkan jenis objek lainnya.

Sebagai contoh jika saya memiliki kelas Person , saya perlu mendefinisikan kriteria berdasarkan mana saya akan membandingkan dua orang . Katakanlah kelas orang ini memiliki variabel instan tinggi dan berat badan.

Jadi membuat objek orang person1 and person2dan untuk membandingkan keduanya dengan menggunakan .equals()saya perlu mengganti metode yang sama dari kelas orang untuk menentukan berdasarkan variabel instance mana (tinggi atau berat) perbandingannya.

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

Untuk memudahkan generalisasi perbandingan objek orang ini, saya telah membuat kelas tes berikut. Bereksperimen dengan konsep-konsep ini akan mengungkapkan banyak fakta .

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

}

Hasil dari eksekusi kelas ini adalah:

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

Perhatikan juga bahwa .equals()biasanya berisi ==untuk pengujian karena ini adalah hal pertama yang ingin Anda uji jika Anda ingin menguji apakah dua objek sama.

Dan ==sebenarnya melihat nilai untuk tipe primitif, untuk objek yang memeriksa referensi.

== referensi selalu operator dibandingkan. Tetapi dalam kasus

metode equals ()

itu tergantung pada implementasi jika kita ditimpa sama dengan metode daripada membandingkan objek pada dasar implementasi yang diberikan dalam metode ditimpa.

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

dalam kode di atas baik objek obj dan objek obj1 berisi data yang sama tetapi referensi tidak sama sehingga sama dengan return false dan == juga. tetapi jika kita menimpa sama dengan metode daripada

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

tahu periksa itu akan mengembalikan benar dan salah untuk kasus yang sama hanya kami menimpa

sama dengan metode.

itu membandingkan objek berdasarkan konten (id) objek

tapi ==

masih membandingkan referensi objek.

Perbedaan utama antara == dan equals () adalah

1) == digunakan untuk membandingkan primitif.

Sebagai contoh :

        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) sama dengan () digunakan untuk membandingkan objek. Sebagai contoh :

        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

==dapat digunakan dalam banyak jenis objek tetapi Anda dapat menggunakan Object.equalsuntuk semua jenis, terutama Strings dan Google Map Markers.

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

    }
  }

---- Output ----- benar salah benar

Mungkin perlu ditambahkan bahwa untuk objek wrapper untuk tipe primitif - yaitu Int, Long, Double - == akan mengembalikan true jika kedua nilai tersebut sama.

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

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

Sebaliknya, menempatkan dua Longs di atas ke dalam dua ArrayLists yang terpisah, sama dengan melihatnya sebagai sama, tetapi == tidak.

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

The String kolam renang (alias magang ) dan Integer kolam renang blur perbedaan lebih lanjut, dan memungkinkan Anda untuk menggunakan ==objek dalam beberapa kasus bukannya.equals

Ini dapat memberi Anda kinerja yang lebih besar (?), Dengan biaya kompleksitas yang lebih besar.

Misalnya:

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

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

Pengorbanan kompleksitas: yang berikut mungkin akan mengejutkan Anda:

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

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

Saya menyarankan Anda untuk menjauh dari optimasi mikro seperti itu, dan selalu gunakan .equalsuntuk objek, dan ==untuk primitif:

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

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

Singkatnya, jawabannya adalah "Ya".

Di Jawa, ==operator membandingkan dua objek untuk melihat apakah mereka menunjuk ke lokasi memori yang sama; sedangkan .equals()metode sebenarnya membandingkan dua objek untuk melihat apakah mereka memiliki nilai objek yang sama.

Pada dasarnya, ==bandingkan jika dua objek memiliki referensi yang sama pada heap, jadi kecuali jika dua referensi terkait dengan objek yang sama, perbandingan ini akan salah.

equals()adalah metode yang diwarisi dari Objectkelas. Metode ini secara default membandingkan jika dua objek memiliki referensi yang sama. Itu berarti:

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

Namun, jika Anda ingin membangun kesetaraan antara dua objek dari kelas yang sama Anda harus mengganti metode ini. Juga sangat penting untuk mengganti metode hashCode()jika Anda telah menimpa equals().

Terapkan hashCode()ketika menetapkan kesetaraan adalah bagian dari Kontrak Obyek Java. Jika Anda bekerja dengan koleksi, dan Anda belum menerapkannya hashCode(), Strange Bad Things dapat terjadi:

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

nullakan dicetak setelah menjalankan kode sebelumnya jika Anda belum menerapkan hashCode().

Karena Java tidak mendukung overloading operator, == berperilaku identik untuk setiap objek tetapi equals () adalah metode, yang dapat ditimpa dalam Java dan logika untuk membandingkan objek dapat diubah berdasarkan aturan bisnis.

Perbedaan utama antara == dan sama dengan di Jawa adalah bahwa "==" digunakan untuk membandingkan primitif sementara metode equals () disarankan untuk memeriksa persamaan objek.

Perbandingan string adalah skenario umum menggunakan keduanya == dan sama dengan metode. Karena kelas java.lang.String menimpa metode yang sama, Ini mengembalikan true jika dua objek String berisi konten yang sama tetapi == hanya akan mengembalikan true jika dua referensi menunjuk ke objek yang sama.

Berikut adalah contoh membandingkan dua String di Jawa untuk kesetaraan menggunakan metode == dan equals () yang akan menghapus beberapa keraguan:

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

}
}