本系列文章准备从以下三方面入手，分别是 equals，hashCode 和常见的面试题。
第一篇文章主要讲解 equals 方法，分为以下部分：
- 关于 equals
- 重写 equals() 原因
- equals() 原则
- getClass 与 instanceof 的区别
- 如何更好地重写 equals()
关于 equals
" == "操作符主要比较的是操作符两端对象的内存地址。如果两个对象的内存地址是一致的，那么就返回 true ；反之，则返回 false 。
Java的数据类型分为：
基本数据类型：8种，分别为byte,short,int,long,float,double,char,boolean
除了 float 和 double 外，其他使用 == 进行数值比较。复合数据类型：类实例化对象， 当他们用 == 进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个 new 出来的对象，他们的比较后的结果为 true，否则比较后结果为 false 。
重写 equals() 原因
JAVA 当中所有的类都是继承于 Object 这个基类的，在 Object 中的基类中定义了一个 equals 的方法，这个方法的初始行为是比较对象的内存地址。
public boolean equals(Object obj) {
return (this == obj);
}
虽然有时候 Object 的 equals() 方法可以满足我们一些基本的要求，但是我们必须要清楚我们很大部分时间都是进行两个对象的比较，这个时候 Object 的 equals() 方法就不可以了，像 String，Integer，Date 等封装类都对 equals() 方法进行了重写。比如 String 类：
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}
equals() 原则
在 Java 规范中，它对 equals() 方法的使用必须要遵循如下几个规则：
equals 方法在非空对象引用上实现相等关系：
自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。
传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。
一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。
对于任何非空引用值 x，x.equals(null) 都应返回 false。
getClass 与 instanceof 的区别
我们在覆写 equals() 方法时，一般都是推荐使用 getClass 来进行类型判断，不是使用 instanceof。我们都清楚 instanceof 的作用是判断其左边对象是否为其右边类的实例，返回 boolean 类型的数据。也可以用来判断继承中的子类的实例是否为父类的实现。
父类Person的实现：
public class Person {
protected String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Person(String name){
this.name = name;
}
@Override
public boolean equals(Object object){
// 1->先比较引用是否相同
if(this == object) {
return true;
}
// 2->再比较类型是否一致
if(object instanceof Person){
// if(object.getClass() == Person.class){
Person p = (Person) object;
// 3->最后比较内容是否相同
if(p.getName() == null || name == null){
return false;
}
else{
return name.equalsIgnoreCase(p.getName ());
}
}
return false;
}
}
子类Employee实现：
public class Employee extends Person{
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Employee(String name,int id){
super(name);
this.id = id;
}
@Override
public boolean equals(Object object){
if(object instanceof Employee){
// if(object.getClass() == Employee.class){
Employee e = (Employee) object;
return super.equals(object) && e.getId() == id;
}
return false;
}
}
测试类 EqualsTest 的实现：
public class EqualsTest {
public static void main(String[] args) {
Employee e1 = new Employee("Mary", 18);
Employee e2 = new Employee("Mary", 19);
Person p1 = new Person("Mary");
System.out.println(p1.equals(e1));
System.out.println(p1.equals(e2));
System.out.println(e1.equals(e2));
}
}
测试结果：
true
true
false
分析：因为 e1、e2 明明是两个不同的类，但为什么会出现这个情况？首先 p1.equals(e1)，是调用 p1 的 equals 方法，该方法使用 instanceof 关键字来检查 e1 是否为 Person 类，这里我们再看看 instanceof：判断其左边对象是否为其右边类的实例，也可以用来判断继承中的子类的实例是否为父类的实现。他们两者存在继承关系，肯定会返回 true 了，而两者 name 又相同，所以结果肯定是 true。所以重写 equals 时推荐使用 getClass 进行类型判断。而不是使用 instanceof。
那 String 类重写 equals 时，为什么使用了 instanceof 关键字呢？原因在于： String 类采用了 final ，即不允许被继承，所以不会出现上述问题。
如何更好地重写 equals()
关于重写 equals() 的模板：
- 先比较引用是否相同
- 再比较类型是否一致
- 最后比较内容是否相同
具体的例子如上述类Person的实现。
