Java 中 == 和 equals() 有什么区别？

Question

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

• == 是引用比较，即两个对象都指向相同的内存位置
• .equals() 计算值的比较在物体中

Answer 1

可能值得补充的是，对于原始类型的包装对象 - 即 Int、Long、Double - 如果两个值相等，== 将返回 true。

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

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

相比之下，将上述两个 Long 放入两个单独的 ArrayList 中， 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.");

Answer 2

字符串池（又名实习）和整数池模糊进一步区别，并且可能允许您在某些情况下对对象使用 == 而不是 .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);

Answer 3

简而言之，答案是“是”。

在Java中，==运算符比较两个对象，看看它们是否指向相同的内存位置；而 .equals() 方法实际上是比较两个对象以查看它们是否具有相同的对象值。

Answer 4

这是同一和等价之间的区别。

a == b 表示 a 和 b 相同，也就是说，它们是内存中完全相同的对象的符号。

a.equals( b ) 意味着它们等价，它们是在某种意义上具有相同值的对象的符号——尽管这些对象可能占据不同的位置记忆。

请注意，对于等价性，如何评估和比较对象的问题就开始发挥作用——复杂的对象在实际用途中可能被视为等价的，即使它们的某些内容不同。有了身份，就不存在这样的问题了。

Answer 5

由于 Java 不支持运算符重载，因此 == 的行为相同
对于每个对象，除了 equals() 都是方法，可以在
Java和比较对象的逻辑可以根据业务进行更改
规则。

Java 中 == 和 equals 的主要区别在于 "==" 用于
比较原语，建议使用 equals() 方法进行检查
对象的平等性。

字符串比较是同时使用 == 和 equals() 方法的常见场景。由于 java.lang.String 类重写了 equals 方法，因此
如果两个 String 对象包含相同的内容，但 == 将返回 true
仅当两个引用指向同一对象时才返回 true。

这里是一个使用 == 和 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);

    }
    }

Answer 6

基本上， == 比较两个对象在堆上是否具有相同的引用，因此除非两个引用链接到同一对象，否则此比较将为 false。

equals() 是从 Object 类继承的方法。默认情况下，此方法会比较两个对象是否具有相同的引用。这意味着：

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

但是，如果您想在两个对象之间建立相等性对于同一类，您应该重写此方法。如果您已经重写了 equals()，那么重写方法 hashCode() 也非常重要。

当建立相等性是 Java 对象契约的一部分时，实现 hashCode()。如果您正在使用集合，并且尚未实现 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"));

如果您没有实现，则在执行前面的代码后将打印 null t 实现了hashCode()。

Answer 7

简而言之，== 检查两个对象是否指向同一内存位置，而 .equals() 计算对象中值的比较。

Answer 8

equals()方法主要是比较对象原来的内容。

如果我们 Write

    String s1 = "Samim";
    String s2 = "Samim";
    String s3 = new String("Samim");
    String s4 = new String("Samim");

    System.out.println(s1.equals(s2));
    System.out.println(s2.equals(s3));
    System.out.println(s3.equals(s4));

输出将会是

true 
true 
true

因为 equals() 方法比较了对象的内容。
在第一个 System.out.println() 中，s1 和 s2 的内容相同，这就是它打印 true 的原因。
对于其他两个 System.out.println() 也是如此。

同样，

    String s1 = "Samim";
    String s2 = "Samim";
    String s3 = new String("Samim");
    String s4 = new String("Samim");
    
    System.out.println(s1 == s2);
    System.out.println(s2 == s3);
    System.out.println(s3 == s4);

输出将是

true
false 
false

因为 == 运算符主要比较对象的引用而不是值。
在第一个 System.out.println() 中，s1 和 s2 的引用相同，这就是它返回 true 的原因。

在第二个System.out.println()中，创建了s3对象，这就是为什么会创建s3的另一个引用，并且s2和s3的引用会有所不同，因此它返回“false”。

第三个System.out.println()，遵循第二个System.out.println()的规则，这就是为什么它会返回“false”。

Answer 9

在Java中，比较对象时，==和equals方法有不同的用途。以下是它们之间差异的简要说明以及示例：

== 运算符：
== 运算符用于引用比较。它检查两个引用是否指向内存中完全相同的对象。

示例：

String str1 = new String("Hello");
String str2 = new String("Hello");
String str3 = str1;

System.out.println(str1 == str2); // false (different objects)
System.out.println(str1 == str3); // true (same object)

在示例中，str1 和 str2 是具有相同内容的不同对象，但 == 返回 false，因为它检查引用相等性。 str3 与 str1 指向同一个对象，因此 str1 == str3 返回 true。

等于方法：
equals方法用于内容或值的比较。它旨在在自定义类中重写，以根据对象的内容提供有意义的比较。

示例：

String str1 = new String("Hello");
String str2 = new String("Hello");

System.out.println(str1.equals(str2)); // true (content-based comparison)

在此示例中，String 类中重写了 equals 来比较字符串的内容。因此，str1.equals(str2) 返回 true，因为字符串的内容相同。

Answer 10

一般来说，你的问题的答案是“是”，但是...

• .equals(...) 只会比较它所写的比较，不多也不少。
• 如果类没有重写 equals 方法，则它默认使用已重写此方法的最近父类的 equals(Object o) 方法。
• 如果没有父类提供重写，则默认为最终父类 Object 中的方法，因此您只剩下 Object#equals(Object o) 方法。根据对象 API，这与 == 相同；也就是说，当且仅当两个变量引用同一个对象（且它们的引用相同）时，它才返回 true。因此，您将测试对象相等，而不是功能相等。
• 如果您覆盖 equals，请务必记住覆盖 hashCode，以免“违反合同”。根据 API，如果两个对象的 equals 方法显示它们是相同的，则从两个对象的 hashCode() 方法返回的结果必须相同相等的。反之则不一定成立。

Answer 11

对于 String 类：

equals() 方法比较 String 实例内部（在堆上）的“值”，无论两个对象引用是否引用同一个 String 实例。如果任意两个 String 类型的对象引用引用同一个 String 实例，那就太好了！如果两个对象引用引用两个不同的 String 实例..它没有什么区别。它是正在比较的每个 String 实例内的“值”（即：字符数组的内容）。

另一方面，“==”运算符比较两个对象引用的值，看看它们是否引用同一个String实例。如果两个对象引用的值“引用”同一个 String 实例，则布尔表达式的结果将为“true”..duh。另一方面，如果两个对象引用的值“引用”不同的 String 实例（即使两个 String 实例具有相同的“值”，即每个 String 实例的字符数组的内容）字符串实例相同）布尔表达式的结果将为“false”。

与任何解释一样，让它深入人心。

我希望这能让事情变得更清楚。

Answer 12

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

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

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

}

你可以比较“==”（相等运算符）和“.equals(...)”（java中的方法）的解释.lang.Object 类）通过这些链接：

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

Answer 13

== 和 equals 之间的区别让我困惑了一段时间，直到我决定仔细研究它。
他们中的许多人说，为了比较字符串，您应该使用 equals 而不是 ==。希望在这个答案中我能够说出区别。

回答这个问题的最好方法是问自己几个问题。那么让我们开始吧：

以下程序的输出是什么：

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

如果你说，

false
true

我会说你是对的但是你为什么这么说 ？
如果你说输出是，

true
false

我会说你错了，但我仍然会问你，为什么你认为这是对的？

好吧，让我们尝试回答这个问题：

以下程序的输出是什么：

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

现在如果你说，

false
true

我会说你错了但是为什么会这样现在错了？
该程序的正确输出是

true
false

请比较上面的程序并尝试思考它。

好的。现在这可能会有所帮助（请阅读以下内容：打印对象的地址 - 不可能，但我们仍然可以使用它。）

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

您可以尝试考虑一下上面代码中最后三行的输出：
对我来说 ideone 打印了这个（你可以在这里查看代码）：

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

哦！现在您看到identityHashCode(mango) 等于identityHashCode(mango2) 但它不等于identityHashCode(mango3)

即使所有字符串变量 - mango、mango2 和 mango3 - 都有 相同值，即“芒果”，identityHashCode()对于所有人来说仍然不一样。

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

我们知道如果 hashcode(x)=N 和 hashcode(y)=N => x 等于 y

我不确定 java 内部是如何工作的，但我假设这就是当我说：

mango = "mango";

java 创建了一个被指向的字符串 "mango" 时发生的情况（引用）由变量mango这样的东西

mango ----> "mango"

现在在下一行，当我说：

mango2 = "mango";

它实际上重用了相同的字符串“mango”，它看起来像这样

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

Mango和mango2都指向到相同的参考
现在，当我说它

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() 通过。
如果我错了，请随时发表评论并告诉我。

Answer 14

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

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

if(foo==bar)
// False (objects are identical but not same)

bar = foo;

if(foo==bar)
// True (Now, objects are identical and same)

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

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

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

Answer 15

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

equals 方法比较对象。

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

Answer 16

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

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

Answer 17

 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

Answer 18

如果您不重写 .equals()，则 == 和 .equals() 都引用同一个对象。

一旦你重写 .equals()，你想要做什么就是你的愿望。您可以将调用对象的状态与传入对象的状态进行比较，也可以只调用 super.equals()

Answer 19

这里是关于关系运算符 == 和方法 .equals() 之间差异的一般规则。 /strong>.

object1 == object2 比较 object1 和 object2 引用的对象是否引用堆中的相同内存位置。

object1.equals(object2) 比较object1 和object2 的值，无论它们位于内存中的位置。

可以很好地证明这一点。

使用字符串场景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 

场景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

该字符串比较可以用作比较其他类型对象的基础。

例如，如果我有一个 Person 类，我需要定义比较两个人的标准。假设这个 person 类有身高和体重的实例变量。

因此创建 person 对象 person1 和 person2 并使用 .equals() 比较这两个对象 code> 我需要重写 person 类的 equals 方法 来定义基于哪些实例变量（身高或体重）进行比较。

但是，== 运算符仍会根据两个对象（person1 和 person2）的内存位置返回结果。

为了便于概括此人对象比较，我创建了以下测试类。 对这些概念进行实验将揭示大量事实。

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

}

该类的执行结果为：

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

Answer 20

请记住 .equals(...) 必须由您要比较的类实现。否则，就没有什么意义了； Object 类的方法版本与比较操作执行相同的操作： 对象#equals。

您真正想要对对象使用比较运算符的唯一时间是在比较枚举时。这是因为 Enum 值一次只有一个实例。例如，给定枚举，

enum FooEnum {A, B, C}

您永远不会同时拥有多个 A 实例，对于 B 和 C 也是如此。这意味着您实际上可以编写如下方法：

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

而且您不会有任何问题。

Answer 21

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

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

Answer 22

== 和 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

Answer 23

示例 1 -

== 和 .equals 方法仅供参考比较。这意味着两个对象是否引用同一个对象。

对象类等于方法实现

public class HelloWorld{
     public static void main(String []args){
       Object ob1 = new Object();
       Object ob2 = ob1;
       System.out.println(ob1 == ob2); // true
       System.out.println(ob1.equals(ob2)); // true
     }    
}

示例 2 -

但是如果我们想使用 equals 方法比较对象内容，则类必须覆盖对象的内容类 equals() 方法并提供内容比较的实现。这里，String类重写了equals方法来进行内容比较。所有包装类都重写了 equals 方法来进行内容比较。

String类equals方法实现

public class HelloWorld{
     public static void main(String []args){
       String ob1 = new String("Hi");
       String ob2 = new String("Hi");
       System.out.println(ob1 == ob2); // false (Both references are referring two different objects)
       System.out.println(ob1.equals(ob2)); // true
     }
}

示例 3 -

如果是字符串，则有一个更多用例。这里，当我们将任何字符串分配给 String 引用时，就会在字符串常量池中创建字符串常量。如果我们将相同的字符串分配给新的字符串引用，则不会创建新的字符串常量，而是会引用现有的字符串常量。

public class HelloWorld{
     public static void main(String []args){
       String ob1 = "Hi";
       String ob2 = "Hi";
       System.out.println(ob1 == ob2); // true
       System.out.println(ob1.equals(ob2)); // true
     }
}

请注意，每当重写 hashCode 方法时，通常都需要重写该方法，以维护 hashCode 方法的一般契约，即相等的对象必须具有相等的哈希码。

Java API 等于() 方法契约

Answer 24

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

== 实际上确实会查看原始类型的值，对于对象，它会检查引用。

Answer 25

== 运算符总是比较引用。但如果是

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 且 == 也返回。
但是如果我们重写 equals 方法而不是

 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）来比较对象

但是==

仍然比较对象的引用。

Answer 26

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

Answer 27

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

    }
  }

- - 输出 - - -
真的
错误的
真的