Sự khác biệt giữa == và bằng () trong Java là gì?

Tôi muốn làm rõ nếu tôi hiểu điều này một cách chính xác:

• == là một so sánh tham chiếu, tức là cả hai đối tượng đều trỏ đến cùng một vị trí bộ nhớ
• .equals() đánh giá để so sánh các giá trị trong các đối tượng

Nói chung, câu trả lời cho câu hỏi của bạn là "có", nhưng ...

• .equals(...) sẽ chỉ so sánh những gì nó được viết để so sánh, không hơn, không kém.
• Nếu một lớp không ghi đè phương thức bằng, thì nó mặc định là equals(Object o)phương thức của lớp cha gần nhất đã ghi đè phương thức này.
• Nếu không có lớp cha nào cung cấp ghi đè, thì nó mặc định là phương thức từ lớp cha cuối cùng, Object và do đó bạn còn lại với Object#equals(Object o)phương thức. Theo API đối tượng, điều này giống như ==; nghĩa là, nó trả về true khi và chỉ khi cả hai biến tham chiếu đến cùng một đối tượng, nếu tham chiếu của chúng là một và giống nhau. Vì vậy, bạn sẽ được kiểm tra cho sự bình đẳng đối tượng và không bình đẳng chức năng .
• Luôn nhớ ghi đè hashCodenếu bạn ghi đè equalsđể không "phá vỡ hợp đồng". Theo API, kết quả trả về từ hashCode()phương thức cho hai đối tượng phải giống nhau nếu equalsphương thức của chúng cho thấy chúng tương đương nhau. Chuyện ngược lại không hẳn là đúng.

Đối với lớp String:

Equals () phương pháp so sánh "giá trị" bên trong trường hợp String (trên heap) không phân biệt nếu hai tài liệu tham khảo đối tượng tham khảo với cùng dụ Chuỗi hay không. Nếu bất kỳ hai tham chiếu đối tượng nào của kiểu String tham chiếu đến cùng một thể hiện Chuỗi thì thật tuyệt! Nếu hai tham chiếu đối tượng tham chiếu đến hai trường hợp Chuỗi khác nhau .. thì nó không tạo ra sự khác biệt. Đó là "giá trị" (nghĩa là: nội dung của mảng ký tự) bên trong mỗi thể hiện Chuỗi đang được so sánh.

Mặt khác, toán tử "==" so sánh giá trị của hai tham chiếu đối tượng để xem liệu chúng có tham chiếu đến cùng một thể hiện Chuỗi hay không . Nếu giá trị của cả hai tham chiếu đối tượng "tham chiếu" cùng một thể hiện Chuỗi thì kết quả của biểu thức boolean sẽ là "true" .. duh. Mặt khác, nếu giá trị của cả hai tham chiếu đối tượng "tham chiếu" các trường hợp Chuỗi khác nhau (mặc dù cả hai trường hợp Chuỗi có "giá trị" giống nhau, nghĩa là, nội dung của các mảng ký tự của mỗi phiên bản Chuỗi là như nhau) kết quả của biểu thức boolean sẽ là "false".

Như với bất kỳ lời giải thích, hãy để nó chìm trong.

Tôi hy vọng điều này sẽ làm sáng tỏ mọi thứ một chút.

Có một số khác biệt nhỏ tùy thuộc vào việc bạn đang nói về "nguyên thủy" hay "Loại đối tượng"; điều tương tự có thể được nói nếu bạn đang nói về các thành viên "tĩnh" hoặc "không tĩnh"; bạn cũng có thể trộn tất cả các thứ trên ...

Đây là một ví dụ (bạn có thể chạy nó):

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

}

Bạn có thể so sánh các giải thích cho "==" (Toán tử đẳng thức) và ".equals (...)" (phương thức trong lớp java.lang.Object) thông qua các liên kết sau:

• ==: 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)

Sự khác biệt giữa == và bằng làm tôi bối rối đôi khi cho đến khi tôi quyết định xem xét kỹ hơn về nó. Nhiều người trong số họ nói rằng để so sánh chuỗi bạn nên sử dụng equalsvà không ==. Hy vọng trong câu trả lời này tôi sẽ có thể nói sự khác biệt.

Cách tốt nhất để trả lời câu hỏi này sẽ là bằng cách tự hỏi một vài câu hỏi. vì vậy hãy bắt đầu:

Đầu ra cho chương trình dưới đây là gì:

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

nếu bạn nói,

false
true

Tôi sẽ nói bạn đúng nhưng tại sao bạn lại nói vậy ? và nếu bạn nói đầu ra là,

true
false

Tôi sẽ nói bạn là sai nhưng tôi vẫn sẽ hỏi bạn, tại sao bạn nghĩ điều đó đúng?

Ok, chúng ta hãy thử trả lời câu hỏi này:

Đầu ra cho chương trình dưới đây là gì:

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

Bây giờ nếu bạn nói,

false
true

Tôi sẽ nói bạn sai nhưng tại sao bây giờ lại sai ? đầu ra chính xác cho chương trình này là

true
false

Hãy so sánh chương trình trên và cố gắng nghĩ về nó.

Đồng ý. Bây giờ điều này có thể giúp (xin vui lòng đọc điều này: in địa chỉ của đối tượng - không thể nhưng chúng ta vẫn có thể sử dụng nó.)

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

bạn có thể thử nghĩ về đầu ra của ba dòng cuối cùng trong đoạn mã trên không: đối với tôi, ideone đã in nó ra ( bạn có thể kiểm tra mã ở đây ):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

Oh! Bây giờ bạn nhìn thấy nhận dạngHashCode (xoài) bằng với idHashCode (mango2) Nhưng nó không bằng nhận dạngHashCode (mango3)

Mặc dù tất cả các biến chuỗi - xoài, xoài2 và xoài3 - có cùng một giá trị, đó là "xoài",identityHashCode() vẫn không giống nhau cho tất cả.

Bây giờ hãy thử bỏ dòng này // mango2 = "mang";và chạy lại lần này bạn sẽ thấy cả baidentityHashCode() đều khác nhau. Hmm đó là một gợi ý hữu ích

chúng tôi biết rằng nếu hashcode(x)=Nvà hashcode(y)=N=>x is equal to y

Tôi không chắc làm thế nào java hoạt động nội bộ nhưng tôi cho rằng đây là những gì đã xảy ra khi tôi nói:

mango = "mango";

java đã tạo ra một chuỗi "mango"được chỉ (tham chiếu) bởi biến mangonhư thế này

mango ----> "mango"

Bây giờ trong dòng tiếp theo khi tôi nói:

mango2 = "mango";

Nó thực sự sử dụng lại cùng một chuỗi "mango"trông giống như thế này

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

Cả xoài và xoài2 đều chỉ đến cùng một tham chiếu Bây giờ khi tôi nói

mango3 = new String("mango")

Nó thực sự tạo ra một tham chiếu (chuỗi) hoàn toàn mới cho "xoài". trông giống như thế này,

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

mango3 ------> "mango"

và đó là lý do tại sao khi tôi đưa ra các giá trị cho mango == mango2nó, nó đưa ra true. và khi tôi đưa ra giá trị cho mango3 == mango2nó, nó đưa ra false(ngay cả khi các giá trị là như nhau).

và khi bạn bỏ ghi chú dòng // mango2 = "mang"; Nó thực sự tạo ra một chuỗi "mang" đã biến đồ thị của chúng tôi như thế này:

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

Đây là lý do tại sao nhận dạngHashCode không giống nhau cho tất cả.

Hy vọng điều này sẽ giúp các bạn. Trên thực tế, tôi muốn tạo một trường hợp thử nghiệm trong đó == fail và bằng () vượt qua. Xin vui lòng bình luận và cho tôi biết nếu tôi sai.

Các == kiểm tra điều hành cho dù hai biến có tài liệu tham khảo tương tự (hay còn gọi là con trỏ đến một địa chỉ bộ nhớ) .

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)

Trong khi phương thức equals () kiểm tra xem hai biến tham chiếu đến các đối tượng có cùng trạng thái (giá trị) hay không .

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

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

Chúc mừng :-)

Bạn sẽ phải ghi đè hàm bằng (cùng với các hàm khác) để sử dụng hàm này với các lớp tùy chỉnh.

Phương thức equals so sánh các đối tượng.

Các ==nhà điều hành nhị phân so sánh địa chỉ bộ nhớ.

Cả == và .equals () đều đề cập đến cùng một đối tượng nếu bạn không ghi đè .equals ().

Đó là mong muốn của bạn những gì bạn muốn làm một khi bạn ghi đè .equals (). Bạn có thể so sánh trạng thái của đối tượng gọi với trạng thái được truyền trong trạng thái của đối tượng hoặc bạn chỉ có thể gọi super.equals ()

==là một toán tử và equals()là một phương thức .

Các toán tử thường được sử dụng để so sánh kiểu nguyên thủy và do đó ==được sử dụng để so sánh địa chỉ bộ nhớ và equals()phương thức được sử dụng để so sánh các đối tượng .

 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

Chỉ cần nhớ rằng .equals(...)phải được thực hiện bởi lớp bạn đang cố gắng so sánh. Mặt khác, không có nhiều điểm; phiên bản của phương thức cho lớp Object thực hiện tương tự như thao tác so sánh: Object # bằng .

Lần duy nhất bạn thực sự muốn sử dụng toán tử so sánh cho các đối tượng là khi bạn so sánh Enums. Điều này là do chỉ có một phiên bản của giá trị Enum tại một thời điểm. Ví dụ, đưa ra enum

enum FooEnum {A, B, C}

Bạn sẽ không bao giờ có nhiều hơn một ví dụ Atại một thời điểm, và tương tự cho Bvà C. Điều này có nghĩa là bạn thực sự có thể viết một phương thức như vậy:

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

Và bạn sẽ không có vấn đề gì.

Khi bạn đánh giá mã, rất rõ ràng rằng (==) so sánh theo địa chỉ bộ nhớ, trong khi bằng (Object o) so sánh hashCode () của các thể hiện. Đó là lý do tại sao người ta nói không phá vỡ hợp đồng giữa bằng () và hashCode () nếu bạn không gặp phải những bất ngờ sau này.

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

Đây là một ngón tay cái chung của quy tắc cho sự khác biệt giữa relational operator ==và the method .equals().

object1 == object2so sánh nếu các đối tượng được tham chiếu bởi object1 và object2 tham chiếu đến cùng một vị trí bộ nhớ trong Heap .

object1.equals(object2)so sánh các giá trị của object1 và object2 bất kể chúng nằm ở đâu trong bộ nhớ .

Điều này có thể được chứng minh tốt bằng cách sử dụng String

cảnh 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 

Kịch bản 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

So sánh chuỗi này có thể được sử dụng làm cơ sở để so sánh các loại đối tượng khác.

Chẳng hạn, nếu tôi có một lớp Người , tôi cần xác định tiêu chí dựa trên đó tôi sẽ so sánh hai người . Giả sử lớp người này có các biến số về chiều cao và cân nặng.

Vì vậy, việc tạo các đối tượng người person1 and person2và để so sánh hai đối tượng này bằng cách sử dụng .equals()tôi cần ghi đè phương thức bằng của lớp người để xác định dựa trên các biến đối tượng (chiều cao hoặc trọng số) mà so sánh sẽ là.

Tuy nhiên, == operator will still return results based on the memory location of the two objects(person1 and person2).

Để dễ khái quát hóa đối tượng người này, tôi đã tạo lớp thử nghiệm sau. Thử nghiệm các khái niệm này sẽ tiết lộ hàng tấn sự thật .

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

}

Kết quả thực hiện lớp này là:

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

Cũng lưu ý rằng .equals()thông thường có chứa ==để kiểm tra vì đây là điều đầu tiên bạn muốn kiểm tra nếu bạn muốn kiểm tra nếu hai đối tượng bằng nhau.

Và ==thực sự nhìn vào các giá trị cho các kiểu nguyên thủy, cho các đối tượng mà nó kiểm tra tham chiếu.

Toán tử == luôn tham chiếu được so sánh. Nhưng trong trường hợp

phương thức bằng ()

nó phụ thuộc vào việc thực hiện nếu chúng ta ghi đè phương thức bằng so với phương thức so sánh đối tượng trên cơ sở thực hiện được đưa ra trong phương thức ghi đè.

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

trong mã ở trên, cả hai đối tượng obj và obj1 đều chứa cùng một dữ liệu nhưng tham chiếu không giống nhau nên bằng trả về false và == cũng được. nhưng nếu chúng ta ghi đè phương thức bằng

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

biết kiểm tra nó sẽ trả về đúng và sai cho cùng một trường hợp chỉ có chúng tôi ghi đè

bằng phương pháp.

nó so sánh đối tượng trên cơ sở nội dung (id) của đối tượng

nhưng ==

vẫn so sánh tài liệu tham khảo của đối tượng.

Sự khác biệt chính giữa == và bằng () là

1) == được sử dụng để so sánh nguyên thủy.

Ví dụ :

        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) bằng () được sử dụng để so sánh các đối tượng. Ví dụ :

        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

==có thể được sử dụng trong nhiều loại đối tượng nhưng bạn có thể sử dụng Object.equalscho bất kỳ loại nào, đặc biệt là Chuỗi và 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");
    }

    }
  }

---- Kết quả ----- đúng sai đúng

Có thể đáng để thêm rằng đối với các đối tượng trình bao cho các kiểu nguyên thủy - tức là Int, Long, Double - == sẽ trả về true nếu hai giá trị bằng nhau.

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

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

Ngược lại, đặt hai Long trên vào hai ArrayLists riêng biệt, bằng nhau sẽ thấy chúng giống nhau, nhưng == không.

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

Nhóm String (còn gọi là interning ) và nhóm Integer làm mờ sự khác biệt hơn nữa và có thể cho phép bạn sử dụng== cho các đối tượng trong một số trường hợp thay vì.equals

Điều này có thể cung cấp cho bạn hiệu suất cao hơn (?), Với chi phí phức tạp hơn.

Ví dụ:

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

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

Sự đánh đổi phức tạp: những điều sau đây có thể làm bạn ngạc nhiên:

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

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

Tôi khuyên bạn nên tránh xa tối ưu hóa vi mô như vậy và luôn luôn sử dụng .equalscho các đối tượng và ==cho các nguyên thủy:

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

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

Nói tóm lại, câu trả lời là "Có".

Trong Java, ==toán tử so sánh hai đối tượng để xem liệu chúng có trỏ đến cùng một vị trí bộ nhớ hay không; trong khi .equals()phương thức thực sự so sánh hai đối tượng để xem chúng có cùng giá trị đối tượng không.

Về cơ bản, == so sánh nếu hai đối tượng có cùng tham chiếu trên heap, vì vậy trừ khi hai tham chiếu được liên kết với cùng một đối tượng, so sánh này sẽ sai.

equals()là một phương thức được kế thừa từ Objectlớp. Phương thức này theo mặc định so sánh nếu hai đối tượng có cùng tham chiếu. Nó có nghĩa là:

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

Tuy nhiên, nếu bạn muốn thiết lập sự bình đẳng giữa hai đối tượng của cùng một lớp, bạn nên ghi đè phương thức này. Nó cũng rất quan trọng để ghi đè phương thức hashCode()nếu bạn đã ghi đèequals() .

Triển khai hashCode()khi thiết lập đẳng thức là một phần của Hợp đồng đối tượng Java. Nếu bạn đang làm việc với các bộ sưu tập và bạn chưa triển khai hashCode(), Những điều tồi tệ có thể xảy ra:

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

nullsẽ được in sau khi thực hiện đoạn code trước nếu bạn đã không được thực hiện hashCode().

Do Java không hỗ trợ quá tải toán tử, == hành xử giống hệt nhau cho mọi đối tượng nhưng bằng () là phương thức, có thể được ghi đè trong Java và logic để so sánh các đối tượng có thể được thay đổi dựa trên các quy tắc nghiệp vụ.

Sự khác biệt chính giữa == và bằng trong Java là "==" được sử dụng để so sánh các nguyên hàm trong khi phương thức equals () được khuyến nghị để kiểm tra sự bằng nhau của các đối tượng.

So sánh chuỗi là một kịch bản phổ biến của việc sử dụng cả hai phương thức == và bằng. Do lớp java.lang.String ghi đè bằng phương thức, Nó trả về true nếu hai đối tượng String chứa cùng một nội dung nhưng == sẽ chỉ trả về true nếu hai tham chiếu được trỏ đến cùng một đối tượng.

Dưới đây là một ví dụ về việc so sánh hai Chuỗi trong Java về phương trình bằng cách sử dụng phương thức == và equals () sẽ xóa một số nghi ngờ:

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

}
}