当我看到equals()
方法的实现时,它什么都不做,但与所做的相同==
。所以我的问题是,当我们拥有==
执行相同工作的操作员时,需要将其作为单独的方法吗?
8 回答
您不能重载==
运算符,但equals(Object)
如果您希望它的行为与==
运算符不同,则可以覆盖,即不比较引用而是实际比较对象(例如使用它们的全部或部分字段)。
此外,如果您确实 override equals(Object)
,也请查看hashCode()
。这两种方法需要兼容(即根据equals(Object)
需要相等的两个对象必须相同hashCode()
),否则会出现各种奇怪的错误(例如,将对象添加到集合或映射时)。
==
比较对象引用,并询问两个引用是否相同。
equals()
比较对象内容,并询问对象是否代表相同的概念。
在原语的情况下,==
操作员检查两个值是否相同。
如果它不是原语,它会检查它是否是两个指向同一对象实例的指针(或引用) 。
该equals()
方法通过使用执行自定义检查,即Object
检查引用==
。但在其他类中,有时会equals()
被覆盖(我不知道这是否是正确的过去分词)。equals()
必须检查内容。
因此,例如:
int i0 = 34;
int i1 = 34;
int i2 = 35;
// results
i0 == i1: true
i1 == i0: true
i2 == i0: false
但是如果我们有非原始人
String str0 = new String("Hello man!");
String str1 = new String("Hello man!");
String str2 = new String("!nam olleH");
String str2copy = str2;
// Results
str0 == str1: false // Pointer to two different object, so == will give false
str1 == str2: false // Idem
str2 == str2copy: true // So this are two pointers to the same object
str0.equals(str1): true // This are not the same objects, but they are equal
str1 == str1: true // Again: two times a pointer to the same object
那么,为什么要str0.equals(str1)
退货true
?因为 String 类具有equals()
. 在那个方法中,它不会通过做检查它们是否相等return this == obj;
但是在那个方法中,有一个完整的检查。我不知道他们使用哪种方法来比较两个字符串,但这里有两种可能的方法:
- 从这两个字符串生成一个哈希码并检查它们是否相等 (
int == int
) - 逐个字符检查它们是否相同。
所以我希望这现在很清楚。
两者之间有一个非常重要的区别。
"==" 比较对象实例。默认的 equals() 实现也这样做。请运行并分析以下代码示例:
public class Person{
String name;
public Person(String name){
this.name = name;
}
//overriding equals
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( name == null ) {
if( other.name != null )
return false;
} else if( !name.equals( other.name ) )
return false;
return true;
}
}
...
...
Person john1 = new Person("John");
Person john2 = new Person("John");
System.out.println("john1 == john2:" + (john1 == john2));
System.out.println("john1.equals(john2):" + john1.equals(john2));
如您所见,“==”将返回false(对象是Person的两个不同实例),而equals将返回true(因为我们定义了两个同名的Person是相等的)
== 运算符用于比较引用。
equals() 方法是在对象定义上定义的。
Dog d =new Dog();
Collar c =new Collar("Red");
d.setCollar(c);
Dog d2=new Dog();
Collar c2=new Collar("Red");
d2.setCollar(c2);
d2.getCollar() ==d.getCollar()
将返回 false ,表示两只狗有两个不同的项圈对象(项目)。它们不共享同一个项圈。
d2.getCollar().equals(d.getCollar())
如果 Collar 被定义为 [Collar are same if Collar of Collar],则返回 true 两只狗的项圈颜色相同。
class Collar{
String color="";
public Collar(String p0){
this.color=p0;
}
boolean equals(Object c){
Collar other=(Collar)c;
return this.color.equals(other.getColor());
}
public String getColor(){
return this.color;
}
}
这样做是为了使这成为可能:
String s1 = new String("foo");
String s2 = new String("foo");
System.out.println(s1 == s2); // false?! Different references!
System.out.println(s1.equals(s2)); // true
如果您检查 的来源String#equals()
,您会发现它已经Object#equals()
适当地覆盖了 以比较彼此的内部字符数组(实际值)。许多其他类也重写了此方法。
在 java 中,如果操作数是原始数据类型,则等于 operator(==) 对两个变量的数据进行操作。但是如果操作数是对象,java 会使用引用来比较它们,因为它无法确定在对象的哪个或哪些字段上进行比较。
因此,只有一种基于用户定义字段进行比较的方法,并且通过覆盖 equals() 方法在对象中定义,因为在 java 中不能覆盖 equals operator(==),因为 java 不支持运算符覆盖。
例如,如果要根据名称比较 Employee,则需要通过覆盖 Employee 类中的 equals 方法来定义其逻辑,如下所示:
public class Employee {
private Integer id;
private String name;
@Override
public boolean equals(Object obj) {
Employee other = (Employee) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
"string" == "string" 将返回 false "string".equals("string") 将返回 true
使用 o1 == o2 您比较对象 1 与 o2 是同一个对象(通过引用)
使用 o1.equals(o2),取决于对象,equals 方法被覆盖,而不是用类似“return o1 == o2”的东西来实现
例如,您创建 2 个集合实例这 2 个集合对象是 2 个不同的对象,您可以在其中的任何一个中添加不同的元素。set1 == set2 将始终返回 false 但 set1.equals(set2) 最终将返回 true 如果 set2 包含与 set1 完全相同的元素...并且因为在 Set 类中覆盖了 equals 方法...
Set 的 Equals 实现是:
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Set))
return false;
Set s = (Set) o;
if (s.size() != c.size())
return false;
return containsAll(s); // Invokes safe containsAll() above
}