使用 .equals() 和 == 运算符比较两个对象

Question

我用一个String 字段构建了一个类。然后我创建了两个对象，我也必须使用== 运算符和.equals() 来比较它们。这是我所做的：

public class MyClass {

    String a;

    public MyClass(String ab) {
        a = ab;
    }

    public boolean equals(Object object2) {
        if(a == object2) { 
            return true;
        }
        else return false;
    }

    public boolean equals2(Object object2) {
        if(a.equals(object2)) {
            return true;
        }
        else return false;
    }



    public static void main(String[] args) {

        MyClass object1 = new MyClass("test");
        MyClass object2 = new MyClass("test");

        object1.equals(object2);
        System.out.println(object1.equals(object2));

        object1.equals2(object2);
        System.out.println(object1.equals2(object2));
    }


}

编译后显示两次错误结果。如果两个对象具有相同的字段 - “test”，为什么它是错误的？

Answer 1

你应该覆盖等于

 public boolean equals (Object obj) {
     if (this==obj) return true;
     if (this == null) return false;
     if (this.getClass() != obj.getClass()) return false;
     // Class name is Employ & have lastname
     Employe emp = (Employee) obj ;
     return this.lastname.equals(emp.getlastname());
 }

Answer 2

您的类可能会实现 Comparable 接口以实现相同的功能。你的类应该实现接口中声明的 compareTo() 方法。

public class MyClass implements Comparable<MyClass>{

    String a;

    public MyClass(String ab){
        a = ab;
    }

    // returns an int not a boolean
    public int compareTo(MyClass someMyClass){ 

        /* The String class implements a compareTo method, returning a 0 
           if the two strings are identical, instead of a boolean.
           Since 'a' is a string, it has the compareTo method which we call
           in MyClass's compareTo method.
        */

        return this.a.compareTo(someMyClass.a);

    }

    public static void main(String[] args){

        MyClass object1 = new MyClass("test");
        MyClass object2 = new MyClass("test");

        if(object1.compareTo(object2) == 0){
            System.out.println("true");
        }
        else{
            System.out.println("false");
        }
    }
}

Answer 3

只有当两个引用指向内存中的同一个对象时，“==”运算符才会返回 true。另一方面，equals() 方法根据对象的内容返回 true。

例子：

String personalLoan = new String("cheap personal loans");
String homeLoan = new String("cheap personal loans");

//since two strings are different object result should be false
boolean result = personalLoan == homeLoan;
System.out.println("Comparing two strings with == operator: " + result);

//since strings contains same content , equals() should return true
result = personalLoan.equals(homeLoan);
System.out.println("Comparing two Strings with same content using equals method: " + result);

homeLoan = personalLoan;
//since both homeLoan and personalLoan reference variable are pointing to same object
//"==" should return true
result = (personalLoan == homeLoan);
System.out.println("Comparing two reference pointing to same String with == operator: " + result);

输出： 使用 == 运算符比较两个字符串：false 使用equals方法比较两个具有相同内容的字符串：true 使用 == 运算符比较指向相同字符串的两个引用：true

您还可以通过以下链接获取更多详细信息：http://javarevisited.blogspot.in/2012/12/difference-between-equals-method-and-equality-operator-java.html?m=1

Answer 4

如果不需要自定义默认的 toString() 函数，另一种方法是重写 toString() 方法，该方法返回所有要比较的属性。然后比较两个对象的 toString() 输出。我使用 IntelliJ IDEA IDE 生成了 toString() 方法，该方法在字符串中包含类名。

public class Greeting {
private String greeting;

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    return this.toString().equals(obj.toString());
}

@Override
public String toString() {
    return "Greeting{" +
            "greeting='" + greeting + '\'' +
            '}';
}
}

Answer 5

这里的输出将是 false ，因为在第一个 sopln 语句中，您尝试将 Myclass 类型的字符串类型变量与另一个 MyClass 类型进行比较，并且由于两者都是 Object 类型并且您使用了“== " 运算符 将 检查 引用 变量 值 保存 实际 内存 而 不是 内存 内 的 实际 连接 . 在第二个 sopln 中，它也与您再次调用 a.equals(object2) 相同，其中 a 是 object1 内部的一个变量。请让我知道您对此的发现。

Answer 6

== 比较对象引用，它检查两个操作数是否指向同一个对象（不是等效对象，相同对象）。

如果你想比较字符串（看它们是否包含相同的字符），你需要使用equals比较字符串。

在您的情况下，如果 MyClass 的两个实例在字符串匹配的情况下确实被认为是相等的，那么：

public boolean equals(Object object2) {
    return object2 instanceof MyClass && a.equals(((MyClass)object2).a);
}

...但通常，如果您要定义一个类，则等效性不仅仅是单个字段的等效性（在这种情况下为a）。

---

旁注：如果您覆盖equals，您几乎总是需要覆盖hashCode。正如equals JavaDoc 中所说：

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

Answer 7

比较两个对象的最佳方法是将它们转换为 json 字符串并比较字符串，这是处理复杂的嵌套对象、字段和/或包含数组的对象时最简单的解决方案。

样本：

import com.google.gson.Gson;


Object a = // ...;
Object b = //...;
String objectString1 = new Gson().toJson(a);
String objectString2 = new Gson().toJson(b); 

if(objectString1.equals(objectString2)){
    //do this
}

Answer 8

覆盖函数equals() 错误。 对象“a”是 String 类的一个实例，“object2”是 MyClass 类的一个实例。它们是不同的类，所以答案是“假”。

Answer 9

你的实现必须是这样的：

public boolean equals2(Object object2) {
    if(a.equals(object2.a)) {
        return true;
    }
    else return false;
}

有了这个实现，你的两种方法都可以工作。

Answer 10

当我们使用 == 时，比较的是对象的引用而不是实际的对象。我们需要重写 equals 方法来比较 Java 对象。

一些附加信息 C++ 有运算符重载，而 Java 不提供运算符重载。 Java 中的其他可能性还有实现 Compare Interface 。它定义了 compareTo 方法。

比较器接口也用于比较两个对象

Answer 11

object.equals 的返回类型已经是布尔值。 无需将其包装在带有分支的方法中。因此，如果您想比较 2 个对象，只需比较它们：

boolean b = objectA.equals(objectB);

b 已经是真或假了。

Answer 12

语句a == object2 和a.equals(object2) 都将始终返回false，因为a 是string 而object2 是MyClass 的一个实例

Answer 13

在下面的代码中，您正在调用被覆盖的方法 .equals()。

public boolean equals2(Object object2) { if(a.equals(object2)) { // 这里你调用了被覆盖的方法，这就是你得到 false 2 次的原因。 返回真； } 否则返回假； }

Answer 14

看起来equals2 只是调用equals，所以它会给出相同的结果。

Answer 15

您的equals2() 方法总是返回与equals() 相同的结果！！

你的代码和我的 cmets：

public boolean equals2(Object object2) {  // equals2 method
    if(a.equals(object2)) { // if equals() method returns true
        return true; // return true
    }
    else return false; // if equals() method returns false, also return false
}