参考答案
在实际应用中，equals和hashCode 容易混淆、出错，本篇通过源码实例详解，厘清equals和hashCode的区别和联系，方便理解与记忆。
1. equals()方法
equals是Object类提供的方法之一。
每一个java类都继承自Object类，所以说每一个对象都有equals这个方法。而我们在用这个方法时却一般都重写这个方法，这是为什么呢？
先来看一个Object类中equals()方法的源码：
public boolean equals(Object obj) {
return (this == obj);
}
可见，只有当一个实例等于它本身的时候，equals()才会返回true值。
通俗地说，此时比较的是两个引用是否指向内存中的同一个对象，也可以说是否实例相等。
而我们在使用equals()来比较两个指向值对象的引用时，往往希望知道它们逻辑上是否相等，而不是它们是否指向同一个对象，这就是我们通常重写这个方法的原因。
Strings1 = new String(“kvill”),String s2 = new String(“kvill”);s1.equals(s2)为ture，
说明String类中已经重写了equals()方法，如果不重写equals()方法，那么s1.equals(s2)默认比较两个对象所指向的内存地址是否相同，返回值必然为false。
当然接下来我们要改写equals()方法，必须要遵守通用约定。来自java.lang.Object的规范，equals方法实现了等价关系，以下是要求遵循的5点：
- 自反性：对于任意的引用值x，x.equals(x)一定为true。
- 对称性：对于任意的引用值x 和 y，当x.equals(y)返回true时，y.equals(x)也一定返回true。
- 传递性：对于任意的引用值x、y和ｚ，如果x.equals(y)返回true，并且y.equals(z)也返回true，那么x.equals(z)也一定返回true。
- 一致性：对于任意的引用值x 和y，如果用于equals比较的对象信息没有被修改，多次调用x.equals(y)要么一致地返回true，要么一致地返回false。
- 非空性：对于任意的非空引用值x，x.equals(null)一定返回false。
2. hashCode()方法
hashcode()这个方法也是从object类中继承过来的，在object类中定义如下：
public native int hashCode();
hashCode()返回该对象的哈希码值，该值通常是一个由该对象的内部地址转换而来的整数，它的实现主要是为了提高哈希表(例如java.util.Hashtable提供的哈希表)的性能。
请牢记：
- 在每个重写了equals方法的类中，必须要重写hashCode方法。
- 如果不这样做，就会违反Object.hashCode的通用约定，从而导致该类无法与所有基于散列值(hash)的集合类结合在一起正常运行。
hashCode()的返回值和equals()的关系如下：
- 如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。
- 如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。
public class TestEquals {
public static void main(String args[]) {
Student s1 = new Student("张一", 6);
Student s2 = new Student("张一", 6);
if (s1.equals(s2)) {
System.out.println("相同 s1的代码:" + s1.hashCode() + " s2的代码:"
+ s2.hashCode());
} else {
System.out.println("不相同");
}
}
}
class Student {
private int age;
private String name;
public Student() {
}
public Student(String name, int age) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int hashCode() {
return (this.name.hashCode() + this.age) * 31;
}
public boolean equals(Object obj) {
boolean result = false;
if (obj == null) {
result = false;
}
if (this == obj) {
result = true;
}
if (obj instanceof Student) {
Student stu = (Student) obj;
if (stu.getName().equals(this.name) && stu.getAge() == (this.age)) {
result = true;
}
} else {
result = false;
}
return result;
}
}
详解：
equals() 是判读两个Set是否相等（前提是equals()在类中被覆盖），==决定引用值是否指向同一对象。
- 当向集合set中增加对象时，首先计算要增加对象的hashCode码，根据该值来得到一个位置来存放当前的对象；当在该位置没有一个对象存在的话，那么集合set认为该对象在集合中不存在，直接增加进去。
- 如果在该位置有一个对象的话，接着将准备增加到集合中的对象与该位置上的对象进行equals方法比较，如果该equals方法返回false，那么集合认为集合中不存在该对象，再进行一次散列，将该对象放到散列后计算出的新地址里，如果equals方法返回true，那么集合认为集合中已经存在该对象了，不会再将该对象增加到集合中了。
当重写equals方法时，必须要重写hashCode方法。
在java的集合中，判断两个对象是否相等的规则是：
- 判断两个对象的hashCode是否相等，如果不相等，认为两个对象也不相等，完毕 ； 如果相等，转入2；
- 判断两个对象用equals运算是否相等，如果不相等，认为两个对象也不相等；如果相等，认为两个对象相等（equals()是判断两个对象是否相等的关键）。
可见，当hashcode()相等时，equals()方法也可能不等。
public static void main(String args[]){
String s1=new String("zhaoxudong"); //此语句创建了两个对象，一个是字符串对象“zhaoxudong”（存放于栈中的字面量），另一个是new后在堆中产生的对象。详细见下面的四.4
String s2=new String("zhaoxudong");
//上述两条语句一共是产生了三个对象，因为栈中只有产生了一个对象。
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
System.out.println(s1.hashCode());//s1.hashcode()等于s2.hashcode() ，指向同一内存的引用
System.out.println(s2.hashCode()); //equals和hashCode方法只用于两个对象的比较和容器中，与对象的创建没有关系
Set hashset=new HashSet();
hashset.add(s1);
hashset.add(s2); /*在添加s1,s2时， hashset认为s1和s2是相等的，所以让s2覆盖了s1;*/
Iterator it=hashset.iterator();
while(it.hasNext()){
System.out.println(it.next());
} //最后在while循环的时候只打印出了一个”zhaoxudong”。
这是因为String类已经重写了equals()方法和hashcode()方法。
再来看下面的实例：
>public class HashSetTest {
public static void main(String[] args) {
HashSet hs=new HashSet();
hs.add(new Student(1,"zhangsan"));
hs.add(new Student(2,"lisi"));
hs.add(new Student(3,"wangwu"));
hs.add(new Student(1,"zhangsan"));
Iterator it=hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
} } }
class Student {
int num;
String name;
Student(int num,String name) {
this.num=num;
this.name=name; }
public String toString() { return num+":"+name; }
}
输出结果为：
1:zhangsan 1:zhangsan 3:wangwu 2:lisi
为什么hashset添加了相等的元素呢？这是不是和hashset的原则违背了呢？答案是：
- 没有因为在根据hashcode()对两次建立newStudent(1,”zhangsan”)对象进行比较时，生成的是不同的哈希码值，所以hashset把他当作不同的对象对待了，当然此时的equals()方法返回的值也不等。
- 生成不同的哈希码值的原因在于，我们自己写的Student类并没有重新自己的hashcode()和equals()方法。
- 所以，在比较时，是继承的object类中的hashcode()方法，它是一个本地方法，比较的是对象的地址（引用地址），使用new方法创建对象，两次生成的当然是不同的对象了，造成的结果就是两个对象的hashcode()返回的值不一样。
那么怎么解决这个问题呢？
在Student类中重新hashcode()和equals()方法。
class Student{
int num;
String name;
Student(int num,String name){
this.num=num;
this.name=name; }
public int hashCode(){ //重写hashCode的方法
return num*name.hashCode(); }
public boolean equals(Object o) {
Student s=(Student)o;
return num==s.num && name.equals(s.name); //&&的优先级比==低，所以前面不必加括号
}
public String toString(){return num+":"+name; }
}
根据重写的方法，即便两次调用了new Student(1,”zhangsan”)，我们在获得对象的哈希码时，根据重写的方法hashcode()，获得的哈希码肯定是一样的。所以运行修改后的程序时，我们会看到重复元素的问题已经消除。
这部分知识在理解与应用过程中都很容易出错，建议多实践，加深对原理与定义的理解。
以上，是Java面试题【equals和hashCode的区别，以及联系】的参考答案。
输出，是最好的学习方法。
欢迎在评论区留下你的问题、笔记或知识点补充~
—end—
拓展阅读：
