equals方法和hashCode方法详解
一、初识equals()和hashCode()方法
1、首先需要明确知道的一点是：hashCode()方法和equals()方法是在Object类中就已经定义了的，所以在java中定义的任何类都会有这两个方法。原始的equals()方法用来比较两个对象的地址值，而原始的hashCode()方法用来返回其所在对象的物理地址，下面来看一下在Object中的定义:
equals:
public boolean equals(Object obj) {//很明显,比较的是两个对象的地址是否相同
return (this == obj);
}
hashCode:
public native int hashCode();//由native修饰，对应一个本地实现
2、如果定义了一个类A，只要它没有重写这两个方法，这两个方法的意义就是如上面所述。请看下面的示例:
示例一
public class Test{
public static void main(String args[]){
Demo d1=new Demo(1,”abc“);
Demo d2=new Demo(1,”abc“);
System.out.println(d1.equals(d2));//输出false，虽然d1和d2的参数都是(1,abc)，但是他们指向不同的内存地址
System.out.println(d1.hashCode());
System.out.println(d2.hashCode());//d1和d2的hashCode不同
}
}
class Demo{
int a;
String b;
public Demo(int a,String b){
this.a=a;
this.b=b;
}
}
二、equals()和hashCode()的重写
前面说到，因为这两个方法都是在Object类中定义，所以java中定义的所有类都会有这两个方法，并且根据实际需要可以重写这两个方法，当方法被重写后，他们所代表的意义就会发生变化，看下面的代码:
示例二
public class TestString{
public static void main(String args[]){
String s1=new String("abc");
String s2=new String("abc");
System.out.println(s1.equals(s2));//输出true，因为String类重写了equals()方法，虽然s1和s2此时指向的地址空间不同，它比较的不再是地址而是String的内容， 此时s1和s2都是"abc"，故返回true
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());//你会发现s1和s2的hashCode相同，因为String同样重写了hashCole()方法，返回的不再是地址，而是根据具体的字符串算出的一个值
}
}
三、equals()和hashCode()方法是怎样被重写的
1、我们来看一下String类中这两个方法的定义:
equals()方法:
public boolean equals(Object anObject) {
if (this == anObject) {//首先进行两个对象地址的比较，如果地址相同了，那么，对象的内容也肯定相同
return true;
}
if (anObject instanceof String) {//比较两个String对象的内容是否相同，相同返回true，不同返回false
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;
}
hashCode()方法:
public int hashCode() {
int h = hash;
if (h == 0) {
int off = offset;
char val[] = value;
int len = count;
for (int i = 0; i < len; i++) {//通过一个特定的算法算出一个hash值，此时的hash值不是对象的地址，而是决定于String的内容是什么，只要两个字符串内容相同，他们的hashCode就相同
h = 31*h + val[off++];
}
hash = h;
}
return h;
}
2、下面我们改写示例一的代码，对equals和hashCode进行重写：
示例三(粉色部分为改动的代码)
class Demo{
int a;
String b;
public Demo(int a,String b){
this.a=a;
this.b=b;
}
public int hashCode(){
return a*(b.hashCode());
}
public boolean equals(Object o){
Demo d=(Demo)o;
return (this.a==d.a)&&(this.b.equals(d.b));
}
}
public class Test{
public static void main(String args[]){
Demo d1=new Demo(1,"abc");
Demo d2=new Demo(1,"abc");
System.out.println(d1.equals(d2));//输出为true，由于重写了equals()，此时比较的不再是对象地址，而是对象内容此时两个对象的内容都是(1,abc)
System.out.println(d1.hashCode());
System.out.println(d2.hashCode());//d1和d2的hash值相同，由于重写了hashCode (),此时返回的不再是地址，而是根据对象内容算出的一个值
}
}
3、小结
1、String 、Math、Integer以及Double等这些封装类已经对equals()和hashCode()方法进行了重写，这两个方法在这些类中已经改变了其本来意义；
2、如果X.equals(Y)，那么它们的X和Y的hashCode值一定相同(这也是java规范中规定的)，不管equals进行的是地址比较还是内容比较；
3、如果两个对象X和Y的hashCode相同，但是X.equals(Y)不一定成立(比如:如果示例三中只重写了hashCode方法，没有重写equals方法，那么System.out.println(d1.equals(d2))一定会输出false)；
四、equals()和hashCode()方法的应用
HashSet集合:
Hashset是java中一个非常重要的集合类，Hashset中不能有重复的元素，当一个元素添加到集合中的时候，Hashset判断元素是否重复的依据是这样的:
1)判断两个对象的hashCode是否相等
如果不相等，认为两个对象也不相等，完毕
如果相等，转入2)
(这一点只是为了提高存储效率而要求的，其实理论上没有也可以，但如果没有，实际使用时效率会大大降低，所以我们这里将其做为必需的)
2)判断两个对象用equals运算是否相等
如果不相等，认为两个对象也不相等
如果相等，认为两个对象相等(equals()是判断两个对象是否相等的关键)
为什么是两条准则，难道用第一条不行吗？不行，因为前面已经说了，hashcode()相等时，equals()方法也可能不等，所以必须用第2条准则进行限制，才能保证加入的为非重复元素。
示例四
import java.util.*;
public class TestString{
public static void main(String args[]){
HashSet
String s1=new String("abc");
String s2=new String("abc");
hSet.add(s1);
hSet.add(s2);
System.out.println(hSet.size());//输出1
}
}
解析:以上代码输出1，即hSet中只有一个元素。当添加s2时，发现s1和s2的hashCode相同；然后调用equals方法返回true，hSet会以为两个元素相同，不会添加s2。
示例五
import java.util.*;
public class TestString{
public static void main(String args[]){
HashSet
String s1=new String("abc");
String s2=new String("123");
hSet.add(s1);
hSet.add(s2);
System.out.println(hSet.size());//输出2
}
}
解析:以上代码输出2，即hSet中有两个元素。当添加s2时，发现s1和s2的hashCode不同，然后s2将添加进去。
示例六
import java.util.*;
public class Test{
public static void main(String args[]){
HashSet
Demo d1=new Demo(1,"abc");
Demo d2=new Demo(1,"abc");
hSet.add(d1);
hSet.add(d2);
System.out.println(hSet.size());//输出2
}
}
class Demo{
int a;
String b;
public Demo(int a,String b){
this.a=a;
this.b=b;
}
}
解析:以上代码输出2，即hSet中有两个元素。当添加d2，发现d1和d2的hashCode不同，然后d2将添加进去。
示例七
import java.util.*;
public class Test{
public static void main(String args[]){
HashSet
Demo d1=new Demo(1,"abc");
Demo d2=new Demo(1,"abc");
hSet.add(d1);
hSet.add(d2);
System.out.println(hSet.size());//输出2
}
}
class Demo{
int a;
String b;
public Demo(int a,String b){
this.a=a;
this.b=b;
}
public boolean equals(Object o){
Demo d=(Demo)o;
return (this.a==d.a)&&(this.b.equals(d.b));
}
}
解析:以上代码输出2，即hSet中有两个元素。当添加d2，发现d1和d2的hashCode相同，然后调用equals方法(此处的equals方法未被重写)，d1和d2的地址不同，故将d2添加到hSet中去。
示例八
import java.util.*;
public class Test{
public static void main(String args[]){
HashSet
Demo d1=new Demo(1,"abc");
Demo d2=new Demo(1,"abc");
hSet.add(d1);
hSet.add(d2);
System.out.println(hSet.size());//输出1
}
}
class Demo{
int a;
String b;
public Demo(int a,String b){
this.a=a;
this.b=b;
}
public int hashCode(){
return a*(b.hashCode());
}
public boolean equals(Object o){
Demo d=(Demo)o;
return (this.a==d.a)&&(this.b.equals(d.b));
}
}
解析:以上代码输出2，即hSet中有两个元素。当添加d2，发现d1和d2的hashCode相同，然后调用equals方法(此处的equals方法已被重写，注意和示例七进行对比)，d1和d2的内容也相同，故将d2不能添加到hSet中去。还可以构造其他示例，我在这里就不一一列举了，读者可以自己进行验证。
小结:当我们向HashSet中添加元素的时候，我们必须明确判断元素间不同的依据是什么，然后确定是两个方法都重写，还是只重写其中的一个方法，或者是两个方法都不用重写。这些都需要视具体的应用而定，但是有一点必须要保证，那就是:如果X.equals(Y)，那么它们的X和Y的hashCode值一定要相同。下面以hibernate框架为例进行分析：
关于在hibernate的pojo类中，重写equals()和hashcode()的问题：
1)，重点是equals，重写hashCode只是技术要求（为了提高效率）
2)，为什么要重写equals呢，因为在java的集合框架中，是通过equals来判断两个对象是否相等的
3)，在hibernate中，经常使用set集合来保存相关对象，而set集合是不允许重复的。我们再来谈谈前面提到在向hashset集合中添加元素时,怎样判断对象是否相同的准则，前面说了两条，其实只要重写equals()这一条也可以。
但当hashset中元素比较多时，或者是重写的equals()方法比较复杂时，我们只用equals()方法进行比较判断，效率也会非常低，所以引入了hashcode()这个方法，只是为了提高效率，但是我觉得这是非常有必要的（所以我们在前面以两条准则来进行hashset的元素是否重复的判断）。
比如可以这样写：
public int hashCode(){
return 1;}//等价于hashcode无效
这样做的效果就是在比较哈希码的时候不能进行判断，因为每个对象返回的哈希码都是1，每次都必须要经过比较equals()方法后才能进行判断是否重复，这当然会引起效率的大大降低。