我构建了一个包含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));
}
}
编译后，结果显示两次false。如果两个对象具有相同的字段 - “test”，为什么会错误？
答案 0 :(得分：121)
==比较对象引用，它检查两个操作数是否指向同一个对象（不是等效的对象，相同的对象）。 / p>
如果您想比较字符串（以查看它们是否包含相同的字符），您需要使用equals比较字符串。
在您的情况下，如果字符串匹配，如果MyClass的两个实例被认为是相等的，那么：
public boolean equals(Object object2) {
return object2 instanceof MyClass && a.equals(((MyClass)object2).a);
}
...但通常如果你要定义一个类，那么等效性等于单个字段的等效性（在这种情况下为a）。
旁注：如果您覆盖equals，则几乎总是需要覆盖hashCode。正如它在equals JavaDoc中所说的那样：
请注意，一旦覆盖此方法，通常需要覆盖
hashCode方法，以便维护hashCode方法的常规协定，该方法声明相等对象必须具有相等的哈希码
答案 1 :(得分：16)
你应该覆盖等于
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());
}
答案 2 :(得分：5)
看起来equals2只是在调用equals，所以它会给出相同的结果。
答案 3 :(得分：4)
您的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
}
答案 4 :(得分：4)
覆盖函数equals（）是错误的。 对象＆＃34; a＆＃34;是 String 类的实例，＆＃34; object2＆＃34;是 MyClass 类的一个实例。它们是不同的类，所以答案是＆＃34; false＆＃34;。
答案 5 :(得分：4)
比较2个对象的最佳方法是将它们转换为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
}
答案 6 :(得分：2)
语句a == object2和a.equals(object2)都将始终返回false，因为a是string而object2是{{1}的实例}}
答案 7 :(得分：2)
您的实施必须：
public boolean equals2(Object object2) {
if(a.equals(object2.a)) {
return true;
}
else return false;
}
通过这种实现，您的两种方法都可以。
答案 8 :(得分：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.
*/
if(this.a.compareTo(someMyClass.a) == 0) return 0;
return 1;
}
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");
}
}
}
答案 9 :(得分：2)
＆＃34; ==＆＃34;仅当两个引用指向内存中的同一对象时，operator才返回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 比较指向同一个String的两个引用与==运算符：true
您还可以从链接中获取更多详细信息：http://javarevisited.blogspot.in/2012/12/difference-between-equals-method-and-equality-operator-java.html?m=1
答案 10 :(得分：2)
如果您不需要自定义默认的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 + '\'' +
'}';
}
}
答案 11 :(得分：1)
object.equals的返回类型已经是布尔值。 没有必要将它包装在带分支的方法中。所以如果你想比较2个对象，只需比较它们：
boolean b = objectA.equals(objectB);
b已经是真或假。
答案 12 :(得分：1)
当我们使用==时，对象的引用与实际对象进行比较。我们需要重写equals方法来比较Java对象。
一些额外的信息C ++有运算符over loading＆amp; Java不提供运算符过载。 java中的其他可能性是实现比较接口。它定义了compareTo方法。
比较器接口也用于比较两个对象
答案 13 :(得分：1)
这里输出将为false，假设你在第一个sopln语句中尝试将Myclass类型的字符串类型变量与其他MyClass类型进行比较，并且它将允许因为两者都是Object类型而你使用了＆＃34 ; ==＆＃34; oprerator将检查保存实际内存的引用变量值而不是内存中的实际contnets。 在第二个sopln中它也与你再次调用a.equals（object2）相同，其中a是一个变量内部object1。请告诉我你的发现。
答案 14 :(得分：-3)
在下面的代码中，您调用的是覆盖方法.equals（）。
public boolean equals2（Object object2）{ if（a.equals（object2））{//这里你调用了overriden方法，这就是你错误2次的原因。 返回true; } 否则返回false; }
答案 15 :(得分：-3)
/** Comparing two or more variables. Here the two items are compared and it will return a boolean true or false.
*
* @return equals
*/
public boolean equals(Object item)
{
String emp1 = this.toString();
String emp2 = item.toString();
return emp1.equals(emp2);
}
@Override
//In case you have more than one variable.
public String toString()
{
return a + b;
}
// a and b represent the variables to display.