Java中== vs equals（）之间有什么区别？-Java 学习之路

517

我想澄清一下我是否理解正确：

== - >是参考比较，即两个对象都指向相同的内存位置
.equals() - >计算对象中值的比较

我的理解是否正确？

24 回答

==运算符测试两个变量是否具有相同的引用（也就是指向内存地址的指针） .

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)

equals（）方法测试两个变量是否引用具有相同状态（值）的对象 .

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

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

干杯:-)

回复于 2024-04-20T12:48:45+08:00

==运算符总是参考进行比较 . 但是如果是的话

equals（）方法

如果我们被覆盖的equals方法比它在重写方法中给出的实现基础上的对象进行比较，则取决于实现 .

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

在上面的代码中，obj和obj1对象都包含相同的数据，但引用不相同，所以equals返回false和==也 . 但如果我们覆盖等于方法而不是

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

知道签出它将返回true和false同样的情况只有我们覆盖

等于方法 .

它比较对象的内容（id）基础上的对象

但==

仍然比较对象的引用 .

回复于 2024-04-20T12:48:45+08:00

0

通常，Java中的equals（）和“==”运算符都用于比较对象以检查相等性，但这里是两者之间的一些差异：

.equals（）方法和==运算符之间的主要区别在于一个是方法而另一个是运算符 .

我们可以使用==运算符进行内容比较的参考比较（地址比较）和.equals（）方法 . 简单来说，==检查两个对象是否指向相同的内存位置，而.equals（）计算对象中值的比较 . 如果类没有覆盖equals方法，则默认情况下它使用覆盖此方法的最近父类的equals（Object o）方法 . 详情请见

回复于 2024-04-20T12:48:45+08:00
0

==运算符：

==是Java中的关系运算符，用于比较两个操作数 . 它用于确定两个操作数是否相等 . 使用==运算符，您可以比较任何基本类型，如int，char，float和Booleans . 比较后，==运算符返回一个布尔值 . 如果两个操作数相等，则==运算符返回一个真值 . 但是，如果两个操作数不相等，则返回false值 . 与对象一起使用时，==运算符会比较两个对象引用，并确定它们是否引用同一实例 .

.equals（）方法

equals（）是String类中可用的方法，用于比较两个字符串并确定它们是否相等 . 作为比较的结果，此方法返回布尔值 . 如果两个字符串包含相同顺序的相同字符，则equals（）方法返回true . 否则，它返回false值 .

举些例子：

http://goo.gl/Sa3q5Y

回复于 2024-04-20T12:48:45+08:00
29

另请注意， .equals() 通常包含 == 用于测试，因为如果您想测试两个对象是否相等，这是您希望测试的第一件事 .

并且 == 实际上会查看基本类型的值，对于检查引用的对象 .

回复于 2024-04-20T12:48:45+08:00
4

关于String类：

equals（） method 比较"value"内部的String实例（在堆上），无论两个对象引用是否引用相同的String实例 . 如果String类型的任何两个对象引用引用相同的String实例那么棒！如果两个对象引用引用两个不同的String实例，则它没有区别 . 它是正在比较的每个String实例中的"value"（即：字符数组的内容） .

另一方面，"==" operator 比较 two object references 的值以查看它们是否引用相同的 String instance . 如果两个对象的值引用"refer to"相同的String实例，那么布尔表达式的结果将是"true" ..duh . 另一方面，如果两个对象引用的值"refer to" different String instances （即使两个String实例具有相同的"values"，即每个String实例的字符数组的内容相同），布尔表达式的结果将是"false" .

与任何解释一样，让它沉入其中 .

我希望这可以解决一些问题 .

回复于 2024-04-20T12:48:45+08:00
2
一般来说，你的问题的答案是“是”，但......
- .equals(...) 只会比较它所写的比较，不多也不少 .
- 如果类未覆盖equals方法，则默认为已覆盖此方法的最近父类的 equals(Object o) 方法 .
- 如果没有父类提供覆盖，则默认为最终父类Object的方法，因此您将使用 Object#equals(Object o) 方法 . 根据Object API，这与 == 相同;也就是说，当且仅当两个变量引用同一个对象时，如果它们的引用是同一个，它才返回true . 因此，您将测试 object equality 而不是 functional equality .
- 如果您覆盖 equals 而不是"break the contract"，请务必覆盖 hashCode . 根据API，从 hashCode() 方法返回的两个对象 must 的结果是如果他们的 equals 方法表明它们是等价的，那就相同 . 反过来不一定是真的 .
回复于 2024-04-20T12:48:45+08:00
2

如果不覆盖.equals（），==和.equals（）都引用同一个对象 .

一旦你覆盖.equals（），你希望你想做什么 . 您可以将调用对象的状态与传入的对象的状态进行比较，也可以调用super.equals（）

回复于 2024-04-20T12:48:45+08:00
3

"==" 实际上是比较两个对象引用，看它们是否指向同一个对象 .

"equals" 这是一个比较实际字符串值的“深度比较” .

回复于 2024-04-20T12:48:45+08:00
51

简而言之，答案是"Yes" . 在Java中， == 运算符比较两个对象以查看它们是否指向相同的内存位置 . 虽然 .equals() 方法实际上比较了两个对象，看它们是否具有相同的对象值 .

回复于 2024-04-20T12:48:45+08:00

对于基本类型的包装器对象，可能值得添加 - 即Int，Long，Double - ==如果两个值相等则返回true .

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

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

相比之下，将上面的两个Longs放入两个独立的ArrayLists中，equals将它们视为相同，但==不是 .

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

回复于 2024-04-20T12:48:45+08:00

39

您必须覆盖equals函数（以及其他函数）才能将其与自定义类一起使用 .

equals方法比较对象 .

== 二元运算符比较内存地址 .

回复于 2024-04-20T12:48:45+08:00

由于Java不支持运算符重载，因此==对于每个对象的行为都相同，但equals（）是方法，可以在Java中重写，并且可以根据业务规则更改比较对象的逻辑 .

Java中==和equals之间的主要区别是“==”用于比较基元，而equals（）方法用于检查对象的相等性 .

String comparison is a common scenario of using both == and equals method. 由于java.lang.String类重写equals方法，如果两个String对象包含相同的内容，则返回true，但如果两个引用指向同一个对象，则返回true .

Here is an example 使用==和equals（）方法比较Java中的两个字符串是否相等，这将清除一些疑问：

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

}
}

回复于 2024-04-20T12:48:45+08:00

5

== 是一个运算符， equals() 是一个方法 .

运算符通常用于原始类型比较，因此 == 用于存储器地址比较， equals() 方法用于比较对象 .

回复于 2024-04-20T12:48:45+08:00

在评估代码时，很明显（==）根据内存地址进行比较，而equals（Object o）则比较实例的hashCode（） . 这就是为什么如果你以后不会遇到意外的话，不要破坏equals（）和hashCode（）之间的 Contract .

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

回复于 2024-04-20T12:48:45+08:00

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

回复于 2024-04-20T12:48:45+08:00

根据您是在谈论“原语”还是“对象类型”，存在一些小差异;如果你在谈论“静态”或“非静态”成员，也可以这样说;你也可以混合以上所有......

这是一个例子（你可以运行它）：

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

}

您可以通过以下链接比较“==”（Equality Operator）和“.equals（...）”（java.lang.Object类中的方法）的解释：

回复于 2024-04-20T12:48:45+08:00

523
请记住， .equals(...) 必须由您要比较的类实现 . 否则，没有太多意义; Object类的方法版本与比较操作的作用相同：Object#equals .

您真正想要使用对象的比较运算符的唯一时间是比较Enums . 这是因为一次只有一个枚举值的实例 . 例如，鉴于枚举
```
enum FooEnum {A, B, C}
```
您一次永远不会有多个 A 实例， B 和 C 也是如此 . 这意味着您实际上可以编写如下方法：
```
public boolean compareFoos(FooEnum x, FooEnum y)
{
    return (x == y);
}
```
而且你没有任何问题 .
回复于 2024-04-20T12:48:45+08:00

==和equals（）之间的主要区别是

1）==用于比较基元 .

例如：

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（）用于比较对象 . 例如：

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

回复于 2024-04-20T12:48:45+08:00

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

    }
  }

----输出----- true false true

回复于 2024-04-20T12:48:45+08:00

4
The String pool (aka interning) and Integer pool 进一步模糊差异，并且可能允许您在某些情况下使用 == 代替对象 .equals

这可以为您带来更高的性能（？），代价是更高的复杂性 .

例如 . ：
```
assert "ab" == "a" + "b";

Integer i = 1;
Integer j = i;
assert i == j;
```
复杂性权衡：以下内容可能让您感到惊讶：
```
assert new String("a") != new String("a");

Integer i = 128;
Integer j = 128;
assert i != j;
```
我建议你远离这种微优化，并始终使用 .equals 作为对象，并使用 == 作为基元：
```
assert (new String("a")).equals(new String("a"));

Integer i = 128;
Integer j = 128;
assert i.equals(j);
```
回复于 2024-04-20T12:48:45+08:00
5
基本上， == 比较两个对象在堆上是否具有相同的引用，因此除非两个引用链接到同一对象，否则此比较将为false .

equals() 是从 Object 类继承的方法 . 默认情况下，此方法会比较两个对象是否相同referece . 它的意思是：

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

但是，如果要在同一个类的两个对象之间 Build 相等性，则应覆盖此方法 . 如果覆盖了 equals() ，则覆盖方法 hashCode() 也非常重要 .

在 Build 相等性时实现 hashCode() 是Java对象 Contract 的一部分 . 如果您正在使用集合，并且尚未实现 hashCode() ，则可能发生奇怪的坏事：
```
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"));
```
如果尚未实现 hashCode() ，则在执行上一代码后将打印 null .
回复于 2024-04-20T12:48:45+08:00
3
==和equals之间的差异让我困惑了一段时间，直到我决定仔细看看它 . 他们中的许多人说，为了比较字符串你应该使用 equals 而不是 == . 希望在这个答案中我能够说出不同之处 .

回答这个问题的最好方法是向自己提出几个问题 . 让我们开始吧：

What is the output for the below program:
```
String mango = "mango";
String mango2 = "mango";
System.out.println(mango != mango2);
System.out.println(mango == mango2);
```
如果你说，
```
false
true
```
我会说你是对的但是 why did you say that ？如果你说输出是，
```
true
false
```
我会说你错了，但我仍会问你，为什么你认为这是对的？

好的，让我们试着回答这个：

What is the output for the below program:
```
String mango = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango3);
System.out.println(mango == mango3);
```
现在如果你说，
```
false
true
```
我会说你错了，但是 why is it wrong now ？这个程序的正确输出是
```
true
false
```
请比较上面的程序，并尝试考虑它 .

好 . 现在这可能有所帮助（请阅读：print the address of object - 不可能，但我们仍然可以使用它 . ）
```
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));
```
你能不能试着考虑上面代码中最后三行的输出：对我来说，想法打印出来（you can check the code here）：
```
false
true
true
false
mango mango
false
true
17225372
17225372
5433634
```
哦!现在你看到 identityHashCode(mango) is equal to identityHashCode(mango2) But it is not equal to identityHashCode(mango3)

即使所有字符串变量 - 芒果，芒果2和芒果3 - 都具有 same 值，即"mango"， identityHashCode() 仍然不是全部相同 .

现在尝试取消注释这一行 // mango2 = "mang"; 并再次运行它，这次你会看到所有三个 identityHashCode() 都不同 . 嗯这是一个有用的提示

我们知道如果 hashcode(x)=N 和 hashcode(y)=N => x is equal to y

我不确定java内部是如何工作的，但我认为这是当我说：
```
mango = "mango";
```
java创建了一个字符串 "mango" ，它由变量 mango 指向（引用），就像这样
```
mango ----> "mango"
```
现在在下一行我说：
```
mango2 = "mango";
```
它实际上重用了相同的字符串 "mango" ，看起来像这样
```
mango ----> "mango" <---- mango2
```
芒果和芒果2指向相同的参考现在，当我说
```
mango3 = new String("mango")
```
它实际上为“芒果”创建了一个全新的引用（字符串） . 看起来像这样，
```
mango -----> "mango" <------ mango2

mango3 ------> "mango"
```
这就是为什么当我推出 mango == mango2 的值时，它会推出 true . 当我输出 mango3 == mango2 的值时，它会输出 false （即使值相同） .

并且当您取消注释该行 // mango2 = "mang"; 它实际上创建了一个字符串"mang"，它将我们的图形转换为：
```
mango ---->"mango"
mango2 ----> "mang"
mango3 -----> "mango"
```
这就是为什么identityHashCode对所有人都不一样 .

希望这可以帮助你们 . 实际上，我想生成一个测试用例，其中==失败并且equals（）通过 . 如果我错了，请随时发表评论并告诉我 .
回复于 2024-04-20T12:48:45+08:00
5

== 可用于许多对象类型，但您可以将 Object.equals 用于任何类型，尤其是字符串和Google Map 标记 .

回复于 2024-04-20T12:48:45+08:00

Java中== vs equals（）之间有什么区别？

24 回答

相关问题