在effective java 一书中，第三章第一节，讲了覆盖equals及hashcode的相关约定。通常情况下，equals表示逻辑值相等，而==则表示引用指向的物理内存地址相同。在java中，Object对象的equals默认使用的是==，因此，如果要实现真正的逻辑值相等，即比较内容相同，则需要对equals进行重写。
1.重写equals测试
如下建立了一个测试对象User，现在User1重写了equals，User2重写了equals和hashcode。
package com.dhb.overrideequals;
public class User {
private int id;
private String name;
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
User1内容：
package com.dhb.overrideequals;
public class User1 {
private int id;
private String name;
public User1(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(obj == null) {
return false;
}
if(getClass() != obj.getClass()){
return false;
}
User1 user1 = (User1) obj;
if(id != user1.id) {
return false;
}
if(name == null) {
if(user1.name != null) {
return false;
}
}else if(!name.equals(user1.name)) {
return false;
}
return true;
}
}
User2内容：
package com.dhb.overrideequals;
public class User2 {
private int id;
private String name;
public User2(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(obj == null) {
return false;
}
if(getClass() != obj.getClass()){
return false;
}
User2 user2 = (User2) obj;
if(id != user2.id) {
return false;
}
if(name == null) {
if(user2.name != null) {
return false;
}
}else if(!name.equals(user2.name)) {
return false;
}
return true;
}
@Override
public int hashCode() {
final int tmp = 31;
int result = 17;
result = tmp*result + id;
result = tmp*result + ((name == null)?0:name.hashCode());
return result;
}
}
测试类：
package com.dhb.overrideequals;
import java.util.HashSet;
import java.util.Set;
public class EqualsTest {
public static void main(String[] args) {
System.out.println("without override.");
testUser();
System.out.println("override equals not override hashcode.");
testUser1();
System.out.println("all override equals and hashcode.");
testUser2();
}
public static void testUser() {
User u1 = new User(1,"test");
User u2 = new User(1,"test");
Set<User> set = new HashSet<>();
set.add(u1);
set.add(u2);
System.out.println(u1.equals(u2));
for(User user : set) {
System.out.println(user.getId()+"->"+user.getName());
}
}
public static void testUser1() {
User1 u1 = new User1(1,"test");
User1 u2 = new User1(1,"test");
Set<User1> set = new HashSet<>();
set.add(u1);
set.add(u2);
System.out.println(u1.equals(u2));
for(User1 user : set) {
System.out.println(user.getId()+"->"+user.getName());
}
}
public static void testUser2() {
User2 u1 = new User2(1,"test");
User2 u2 = new User2(1,"test");
Set<User2> set = new HashSet<>();
set.add(u1);
set.add(u2);
System.out.println(u1.equals(u2));
for(User2 user : set) {
System.out.println(user.getId()+"->"+user.getName());
}
}
}
执行上述测试类，输出如下：
without override.
false
1->test
1->test
override equals not override hashcode.
true
1->test
1->test
all override equals and hashcode.
true
1->test
可以发现，如果不对equals进行重写，相同内容的对象User(1,"test") ，u1 和u2会被认为是不同的对象，equals时返回false。同时在hashset中被认为是两个对象。
如果只重写equals，u1和u2执行equals返回true，但是在hashSet中还是不同的对象，此种情况下使用hash相关的集合就会有问题。只有同时覆盖了hashcode和equals,才能达到预期。因此，覆盖equals必须覆盖hashcode。
2.不用覆盖equals的条件
在effictive java一书中，定义的不用覆盖equals的条件如下：
1.类的每个实例本质上都是唯一的
用这个类表示活动实体，而不是值，如Thread，用Object提供的equals就能满足要求。
2.不关心类是否提供逻辑相等的测试功能
java.util.Random覆盖了equals, 用来检查两个Random实例产生的随机数序列是否相同，但是这个功能并非使用者所需，也就是没有任何意义。
3.超类已经覆盖了equals, 对于子类也适用
这种情况父类已经覆盖，无需重复覆盖。
4.类是私有或者包级私有，确定它的equals永远不会被调用。
此种情况下应该抛出异常。
@Override
public boolean equals(Object o) {
throw new AssertionError();
}
除上述情况外，其他任何情况都需要正确覆盖equals并同时覆盖hashcode.
3.覆盖equals的约定
equals实现了等价关系，具有如下特点
1.自反性（reflexivity）:任何非空值x,x.equals(x) 返回true.
x != null && x.equals(x) == true
2.对称性(symmetry):对任何非空值x,y. 当且仅当y.equals(x)返回true时，x.equals(y)必须返回true。
if((x != null && y != null) && x.equals(y))可以推出y.equals(x)
3.传递性(transitivity).对任何非空的值x、y、z。如果x.equals(y)返回true,且y.equals(z)返回true,则x.equals(z)返回true。
(x != null &&y != null &&z != null )&& x.equals(y) && y.equals(z)可以推出x.equals(z)
4.一致性(consistency):对于任何非空值x,y.只要equals的比较操作在对象中所用的信息没有被修改，多次调用x.equals(y)就一致返回true或者false.
5.非空性(Non-nullity):对于非null的x,x.equals(null) 返回值一顶为false。
4.覆盖equals注意事项
1.覆盖时总是要覆盖hashCode方法
2.别想着把equals做得太“智能”
3.不要把equals方法中的Object参数对象替换成其他类型（从Override变成Overload!）
4.在每次覆盖equals方法都逐一审查equals 的五个约定。
