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,虽然d1d2的参数都是(1,abc),但是他们指向不同的内存地址
  System.out.println(d1.hashCode());
  System.out.println(d2.hashCode());//d1d2hashCode不同
 }
}

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的内容, 此时s1s2都是"abc",故返回true
  System.out.println(s1.hashCode());
  System.out.println(s2.hashCode());//你会发现s1s2hashCode相同,因为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());//d1d2hash值相同,由于重写了hashCode (),此时返回的不再是地址,而是根据对象内容算出的一个值
 }
}

3、小结

 

1String MathInteger以及Double等这些封装类已经对equals()hashCode()方法进行了重写,这两个方法在这些类中已经改变了其本来意义;

2、如果X.equals(Y),那么它们的XYhashCode值一定相同(这也是java规范中规定的),不管equals进行的是地址比较还是内容比较

3、如果两个对象XYhashCode相同,但是X.equals(Y)不一定成立(比如:如果示例三中只重写了hashCode方法,没有重写equals方法,那么System.out.println(d1.equals(d2))一定会输出false)


 

四、equals()和hashCode()方法的应用

HashSet集合:

Hashsetjava中一个非常重要的集合类,Hashset中不能有重复的元素,当一个元素添加到集合中的时候,Hashset判断元素是否重复的依据是这样的:

1)判断两个对象的hashCode是否相等 
   如果不相等,认为两个对象也不相等,完毕 
   如果相等,转入2) 
  (这一点只是为了提高存储效率而要求的,其实理论上没有也可以,但如果没有,实际使用时效率会大大降低,所以我们这里将其做为必需的)
2)判断两个对象用equals运算是否相等 
   如果不相等,认为两个对象也不相等 
   如果相等,认为两个对象相等(equals()是判断两个对象是否相等的关键
  为什么是两条准则,难道用第一条不行吗?不行,因为前面已经说了,hashcode()相等时,equals()方法也可能不等,所以必须用第2条准则进行限制,才能保证加入的为非重复元素。

示例四

import java.util.*;
public class TestString{
 public static void main(String args[]){
  HashSet hSet=new 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时,发现s1s2hashCode相同;然后调用equals方法返回truehSet会以为两个元素相同,不会添加s2

 

示例五

 import java.util.*;
public class TestString{
 public static void main(String args[]){
  HashSet hSet=new 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时,发现s1s2hashCode不同,然后s2将添加进去。

 

示例六

import java.util.*;
public class Test{
 public static void main(String args[]){
  HashSet hSet=new 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,发现d1d2hashCode不同,然后d2将添加进去。

 

示例七

import java.util.*;
public class Test{
 public static void main(String args[]){
  HashSet hSet=new 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,发现d1d2hashCode相同,然后调用equals方法(此处的equals方法未被重写)d1d2的地址不同,故将d2添加到hSet中去。

 

示例八

import java.util.*;
public class Test{
 public static void main(String args[]){
  HashSet hSet=new 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,发现d1d2hashCode相同,然后调用equals方法(此处的equals方法已被重写,注意和示例七进行对比)d1d2的内容也相同,故将d2不能添加到hSet中去。还可以构造其他示例,我在这里就不一一列举了,读者可以自己进行验证。

 

小结:当我们向HashSet中添加元素的时候,我们必须明确判断元素间不同的依据是什么,然后确定是两个方法都重写,还是只重写其中的一个方法,或者是两个方法都不用重写。这些都需要视具体的应用而定,但是有一点必须要保证,那就是:如果X.equals(Y),那么它们的XYhashCode值一定要相同。下面以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()方法后才能进行判断是否重复,这当然会引起效率的大大降低。

 

你可能感兴趣的:(java)