Java 使用.equals（）和==运算符比较两个对象

我用一个

字符串
字段构造了一个类。然后我创建了两个对象，我必须使用
=
操作符和
.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));
    }


}

编译后，结果显示两次false。如果两个对象具有相同的字段-“test”
您的
equals2（）
方法将始终返回与
equals（）相同的值

您的代码和我的评论：

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
}

看起来
equals2
只是调用
equals
，所以它会给出相同的结果。
==
比较对象引用，检查两个操作数是否指向相同的对象（不是等价的对象，相同的对象）

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

在您的情况下，如果字符串匹配，则认为
MyClass
的两个实例实际上相等，则：

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

…但通常，如果定义一个类，那么等价性比单个字段的等价性更重要（
a
）


旁注：如果覆盖
等于
，则几乎总是需要覆盖。正如它在报告中所说：

请注意，每当重写
hashCode
方法时，通常需要重写该方法，以便维护
hashCode
方法的一般约定，该约定规定相同的对象必须具有相同的哈希代码

在下面的代码中，您正在调用重写的方法.equals（）

公共布尔等式2（对象对象2）{
如果（a.equals（object2））{//这里您正在调用重写的方法，这就是为什么会出现两次false。
返回true；
}
否则返回false；
}语句
a==object2
和
a.equals（object2）
都将始终返回
false
，因为
a
是
string
而
object2
是
MyClass
的一个实例，object.equals的返回类型已经是布尔值。
没有必要将它包装在带有分支的方法中。因此，如果要比较两个对象，只需比较它们：

boolean b = objectA.equals(objectB);

b已经是真或假。
当我们使用==时，对象的引用与实际对象进行比较。我们需要重写equals方法来比较Java对象

<>一些附加信息C++具有操作符重载，java不提供操作符重载。
java中的其他可能性还有实现比较接口，它定义了一个compareTo方法

比较器接口也用于比较两个对象
您的实现必须喜欢：

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

在这个实现中，两种方法都可以使用。
覆盖函数equals（）是错误的。
对象“a”是String类的实例，“object2”是MyClass类的实例。它们是不同的类，所以答案是“false”。
您应该覆盖equals

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

比较两个对象的最佳方法是将它们转换为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
}

您的类可以实现类似的接口来实现相同的功能。类应该实现接口中声明的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");
        }
    }
}

公共类MyClass实现了可比较的{
字符串a；
公共MyClass（字符串ab）{
a=ab；
}
//返回整数而不是布尔值
public int compareTo（MyClass someMyClass）{
/*String类实现了compareTo方法，返回0
如果两个字符串相同，而不是布尔值。
因为“a”是一个字符串，所以它具有我们调用的compareTo方法
在MyClass的compareTo方法中。
*/
将此.a.compareTo返回（someMyClass.a）；
}
公共静态void main（字符串[]args）{
MyClass object1=新的MyClass（“测试”）；
MyClass object2=新的MyClass（“测试”）；
if（object1.compareTo（object2）==0）{
System.out.println（“真”）；
}
否则{
System.out.println（“假”）；
}
}
}
只有当两个引用指向内存中的同一对象时，“==”运算符才会返回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

您还可以从以下链接获得更多详细信息：
这里的输出将为false，因为在第一个sopln语句中，您试图将Myclass type的字符串类型变量与另一个Myclass类型进行比较，这将允许，因为两者都是对象类型，并且您使用了“==”检查参考变量值的运算器，该参考变量值包含实际内存，而不是内存中的实际内容。
在第二个sopln中，它与再次调用a.equals（object2）相同，其中a是object1中的变量。请告诉我您的发现。
如果您不需要自定义默认的toString（）函数，另一种方法是重写toString（）方法，该方法返回所有要比较的属性。然后比较两个对象的toString（）输出。我使用IntelliJ IDEA生成了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 + '\'' +
            '}';
}
}

顺便说一句，看看
equals
和
equals2
：任何时候你有
if（a）{return true；}或者{return false；}
形式的东西，你可能应该写
return a
@yshavit，你的意思是，从布尔值改为字符串？不，你的代码是询问是否是布尔值