HashMap的工作原理-hashcode和equals的区别

来源:互联网 发布:七星彩计划软件 编辑:程序博客网 时间:2024/06/01 09:16
先来试想一个场景,如果你想查找一个集合中是否包含某个对象,那么程序应该怎么写呢?通常的做法是逐一取出每个元素与要查找的对象一一比较,当发现两者进行equals比较结果相等时,则停止查找并返回true,否则,返回false。但是这个做法的一个缺点是当集合中的元素很多时,譬如有一万个元素,那么逐一的比较效率势必下降很快。于是有人发明了一种哈希算法来提高从该集合中查找元素的效率,这种方式将集合分成若干个存储区域(可以看成一个个桶),每个对象可以计算出一个哈希码,可以根据哈希码分组,每组分别对应某个存储区域,这样一个对象根据它的哈希码就可以分到不同的存储区域(不同的桶中)。如下图所示:

                                            

实际的使用中,一个对象一般有key和value,可以根据key来计算它的hashCode。假设现在全部的对象都已经根据自己的hashCode值存储在不同的存储区域中了,那么现在查找某个对象(根据对象的key来查找),不需要遍历整个集合了,现在只需要计算要查找对象的key的hashCode,然后找到该hashCode对应的存储区域,在该存储区域中来查找就可以了,这样效率也就提升了很多。说了这么多相信你对hashCode的作用有了一定的了解,下面就来看看hashCode和equals的区别和联系。

在研究这个问题之前,首先说明一下JDK对equals(Object obj)和hashCode()这两个方法的定义和规范:在Java中任何一个对象都具备equals(Object obj)和hashCode()这两个方法,因为他们是在Object类中定义的。 equals(Object obj)方法用来判断两个对象是否“相同”,如果“相同”则返回true,否则返回false。 hashCode()方法返回一个int数,在Object类中的默认实现是“将该对象的内部地址转换成一个整数返回”。 

下面是官方文档给出的一些说明:

[java] view plain copy
  1. hashCode 的常规协定是:     
  2. 在 Java 应用程序执行期间,在同一对象上多次调用 hashCode 方法时,必须一致地返回相同的整数,前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。     
  3. 如果根据 equals(Object) 方法,两个对象是相等的,那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。     
  4. 以下情况不 是必需的:如果根据 equals(java.lang.Object) 方法,两个对象不相等,那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是,程序员应该知道,为不相等的对象生成不同整数结果可以提高哈希表的性能。     
  5. 实际上,由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。(这一般是通过将该对象的内部地址转换成一个整数来实现的,但是 JavaTM 编程语言不需要这种实现技巧。)     
  6.     
  7. 当equals方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode 方法的常规协定,该协定声明相等对象必须具有相等的哈希码

下面是我查阅了相关资料之后对以上的说明做的归纳总结:

1.若重写了equals(Object obj)方法,则有必要重写hashCode()方法。

2.若两个对象equals(Object obj)返回true,则hashCode()有必要也返回相同的int数。

3.若两个对象equals(Object obj)返回false,则hashCode()不一定返回不同的int数。

4.若两个对象hashCode()返回相同int数,则equals(Object obj)不一定返回true。

5.若两个对象hashCode()返回不同int数,则equals(Object obj)一定返回false。

6.同一对象在执行期间若已经存储在集合中,则不能修改影响hashCode值的相关信息,否则会导致内存泄露问题。


想要弄清楚以上六点,先要知道什么时候需要重写equals和hashCode。一般来说涉及到对象之间的比较大小就需要重写equals方法,但是为什么第一点说重写了equals就需要重写hashCode呢?实际上这只是一条规范,如果不这样做程序也可以执行,只不过会隐藏bug。一般一个类的对象如果会存储在HashTable,HashSet,HashMap等散列存储结构中,那么重写equals后最好也重写hashCode,否则会导致存储数据的不唯一性(存储了两个equals相等的数据)。而如果确定不会存储在这些散列结构中,则可以不重写hashCode。但是个人觉得还是重写比较好一点,谁能保证后期不会存储在这些结构中呢,况且重写了hashCode也不会降低性能,因为在线性结构(如ArrayList)中是不会调用hashCode,所以重写了也不要紧,也为后期的修改打了补丁。

下面来看一张对象放入散列集合的流程图:



从上面的图中可以清晰地看到在存储一个对象时,先进行hashCode值的比较,然后进行equals的比较。可能现在你已经对上面的6点归纳有了一些认识。我们还可以通过JDK中得源码来认识一下具体hashCode和equals在代码中是如何调用的。

HashSet.java 

[java] view plain copy
  1. public boolean add(E e) {  
  2.     return map.put(e, PRESENT)==null;  
  3.     } 

HashMap.java
[java] view plain copy
  1.  public V put(K key, V value) {  
  2.         if (key == null)  
  3.             return putForNullKey(value);  
  4.         int hash = hash(key.hashCode());  
  5.         int i = indexFor(hash, table.length);  
  6.         for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
  7.             Object k;  
  8.             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
  9.                 V oldValue = e.value;  
  10.                 e.value = value;  
  11.                 e.recordAccess(this);  
  12.                 return oldValue;  
  13.             }  
  14.         }  
  15.   
  16.         modCount++;  
  17.         addEntry(hash, key, value, i);  
  18.         return null;  
  19.     }


最后再来看几个测试的例子吧:

测试一:覆盖equals(Object obj)但不覆盖hashCode(),导致数据不唯一性

[java] view plain copy
  1. public class HashCodeTest {  
  2.     public static void main(String[] args) {  
  3.         Collection set = new HashSet();  
  4.         Point p1 = new Point(11);  
  5.         Point p2 = new Point(11);  
  6.   
  7.         System.out.println(p1.equals(p2));  
  8.         set.add(p1);   //(1)  
  9.         set.add(p2);   //(2)  
  10.         set.add(p1);   //(3)  
  11.   
  12.         Iterator iterator = set.iterator();  
  13.         while (iterator.hasNext()) {  
  14.             Object object = iterator.next();  
  15.             System.out.println(object);  
  16.         }  
  17.     }  
  18. }  
  19.   
  20. class Point {  
  21.     private int x;  
  22.     private int y;  
  23.   
  24.     public Point(int x, int y) {  
  25.         super();  
  26.         this.x = x;  
  27.         this.y = y;  
  28.     }  
  29.   
  30.     @Override  
  31.     public boolean equals(Object obj) {  
  32.         if (this == obj)  
  33.             return true;  
  34.         if (obj == null)  
  35.             return false;  
  36.         if (getClass() != obj.getClass())  
  37.             return false;  
  38.         Point other = (Point) obj;  
  39.         if (x != other.x)  
  40.             return false;  
  41.         if (y != other.y)  
  42.             return false;  
  43.         return true;  
  44.     }  
  45.   
  46.     @Override  
  47.     public String toString() {  
  48.         return "x:" + x + ",y:" + y;  
  49.     }  
  50.   
  51. }  



输出结果:

[java] view plain copy
  1. true  
  2. x:1,y:1  
  3. x:1,y:1  


原因分析:

(1)当执行set.add(p1)时(1),集合为空,直接存入集合;

(2)当执行set.add(p2)时(2),首先判断该对象(p2)的hashCode值所在的存储区域是否有相同的hashCode,因为没有覆盖hashCode方法,所以jdk使用默认Object的hashCode方法,返回内存地址转换后的整数,因为不同对象的地址值不同,所以这里不存在与p2相同hashCode值的对象,因此jdk默认不同hashCode值,equals一定返回false,所以直接存入集合。

 (3)当执行set.add(p1)时(3),时,因为p1已经存入集合,同一对象返回的hashCode值是一样的,继续判断equals是否返回true,因为是同一对象所以返回true。此时jdk认为该对象已经存在于集合中,所以舍弃。


测试二:覆盖hashCode方法,但不覆盖equals方法,仍然会导致数据的不唯一性

修改Point类:

[java] view plain copy
  1. class Point {  
  2.     private int x;  
  3.     private int y;  
  4.   
  5.     public Point(int x, int y) {  
  6.         super();  
  7.         this.x = x;  
  8.         this.y = y;  
  9.     }  
  10.   
  11.     @Override  
  12.     public int hashCode() {  
  13.         final int prime = 31;  
  14.         int result = 1;  
  15.         result = prime * result + x;  
  16.         result = prime * result + y;  
  17.         return result;  
  18.     }  
  19.   
  20.     @Override  
  21.     public String toString() {  
  22.         return "x:" + x + ",y:" + y;  
  23.     }  
  24.   
  25. }  


输出结果:
[java] view plain copy
  1. false  
  2. x:1,y:1  
  3. x:1,y:1

原因分析:

(1)当执行set.add(p1)时(1),集合为空,直接存入集合;

(2)当执行set.add(p2)时(2),首先判断该对象(p2)的hashCode值所在的存储区域是否有相同的hashCode,这里覆盖了hashCode方法,p1和p2的hashCode相等,所以继续判断equals是否相等,因为这里没有覆盖equals,默认使用'=='来判断,所以这里equals返回false,jdk认为是不同的对象,所以将p2存入集合。

 (3)当执行set.add(p1)时(3),时,因为p1已经存入集合,同一对象返回的hashCode值是一样的,并且equals返回true。此时jdk认为该对象已经存在于集合中,所以舍弃。


综合上述两个测试,要想保证元素的唯一性,必须同时覆盖hashCode和equals才行。
(注意:在HashSet中插入同一个元素(hashCode和equals均相等)时,会被舍弃,而在HashMap中插入同一个Key(Value 不同)时,原来的元素会被覆盖。)

测试三:在内存泄露问题
[java] view plain copy
  1. public class HashCodeTest {  
  2.     public static void main(String[] args) {  
  3.         Collection set = new HashSet();  
  4.         Point p1 = new Point(11);  
  5.         Point p2 = new Point(12);  
  6.   
  7.         set.add(p1);  
  8.         set.add(p2);  
  9.           
  10.         p2.setX(10);  
  11.         p2.setY(10);  
  12.           
  13.         set.remove(p2);  
  14.   
  15.         Iterator iterator = set.iterator();  
  16.         while (iterator.hasNext()) {  
  17.             Object object = iterator.next();  
  18.             System.out.println(object);  
  19.         }  
  20.     }  
  21. }  
  22.   
  23. class Point {  
  24.     private int x;  
  25.     private int y;  
  26.   
  27.     public Point(int x, int y) {  
  28.         super();  
  29.         this.x = x;  
  30.         this.y = y;  
  31.     }  
  32.   
  33.   
  34.     public int getX() {  
  35.         return x;  
  36.     }  
  37.   
  38.   
  39.     public void setX(int x) {  
  40.         this.x = x;  
  41.     }  
  42.   
  43.   
  44.     public int getY() {  
  45.         return y;  
  46.     }  
  47.   
  48.   
  49.     public void setY(int y) {  
  50.         this.y = y;  
  51.     }  
  52.   
  53.   
  54.     @Override  
  55.     public int hashCode() {  
  56.         final int prime = 31;  
  57.         int result = 1;  
  58.         result = prime * result + x;  
  59.         result = prime * result + y;  
  60.         return result;  
  61.     }  
  62.   
  63.   
  64.     @Override  
  65.     public boolean equals(Object obj) {  
  66.         if (this == obj)  
  67.             return true;  
  68.         if (obj == null)  
  69.             return false;  
  70.         if (getClass() != obj.getClass())  
  71.             return false;  
  72.         Point other = (Point) obj;  
  73.         if (x != other.x)  
  74.             return false;  
  75.         if (y != other.y)  
  76.             return false;  
  77.         return true;  
  78.     }  
  79.   
  80.   
  81.     @Override  
  82.     public String toString() {  
  83.         return "x:" + x + ",y:" + y;  
  84.     }  
  85.   
  86. }  


运行结果:
[java] view plain copy
  1. x:1,y:1  
  2. x:10,y:10

原因分析:
    假设p1的hashCode为1,p2的hashCode为2,在存储时p1被分配在1号桶中,p2被分配在2号筒中。这时修改了p2中与计算hashCode有关的信息(x和y),当调用remove(Object obj)时,首先会查找该hashCode值得对象是否在集合中。假设修改后的hashCode值为10(仍存在2号桶中),这时查找结果空,jdk认为该对象不在集合中,所以不会进行删除操作。然而用户以为该对象已经被删除,导致该对象长时间不能被释放,造成内存泄露。解决该问题的办法是不要在执行期间修改与hashCode值有关的对象信息,如果非要修改,则必须先从集合中删除,更新信息后再加入集合中。

总结:
   1.hashCode是为了提高在散列结构存储中查找的效率,在线性表中没有作用。
   2.equals和hashCode需要同时覆盖。
   3.若两个对象equals返回true,则hashCode有必要也返回相同的int数。

4.若两个对象equals返回false,则hashCode不一定返回不同的int数,但为不相等的对象生成不同hashCode值可以提高哈希表的性能。

5.若两个对象hashCode返回相同int数,则equals不一定返回true。

6.若两个对象hashCode返回不同int数,则equals一定返回false。

   7.同一对象在执行期间若已经存储在集合中,则不能修改影响hashCode值的相关信息,否则会导致内存泄露问题。

谈到hashcode()和equals()就不能不说到hashset,hashmap,hashtable中的使用,具体是怎样呢,请看如下分析:Hashset是继承Set接口,Set接口又实现Collection接口,这是层次关系。那么hashset是根据什么原理来存取对象的呢?在hashset中不允许出现重复对象,元素的位置也是不确定的。在hashset中又是怎样判定元素是否重复的呢?这就是问题的关键所在,经过一下午的查询求证终于获得了一点启示,和大家分享一下,在java的集合中,判断两个对象是否相等的规则是:1),判断两个对象的hashCode是否相等      如果不相等,认为两个对象也不相等,完毕      如果相等,转入2)(这一点只是为了提高存储效率而要求的,其实理论上没有也可以,但如果没有,实际使用时效率会大大降低,所以我们这里将其做为必需的。后面会重点讲到这个问题。)2),判断两个对象用equals运算是否相等      如果不相等,认为两个对象也不相等      如果相等,认为两个对象相等(equals()是判断两个对象是否相等的关键)为什么是两条准则,难道用第一条不行吗?不行,因为前面已经说了,hashcode()相等时,equals()方法也可能不等,所以必须用第2条准则进行限制,才能保证加入的为非重复元素。比如下面的代码:

public static void main(String args[]){String s1=new String("zhaoxudong");String s2=new String("zhaoxudong");System.out.println(s1==s2);//falseSystem.out.println(s1.equals(s2));//trueSystem.out.println(s1.hashCode());//s1.hashcode()等于s2.hashcode()System.out.println(s2.hashCode());Set hashset=new HashSet();hashset.add(s1);hashset.add(s2);Iterator it=hashset.iterator();            while(it.hasNext())            {             System.out.println(it.next());            }

最后在while循环的时候只打印出了一个”zhaoxudong”。输出结果为:false true -967303459 -967303459这是因为String类已经重写了equals()方法和hashcode()方法,所以在根据上面的第1.2条原则判定时,hashset认为它们是相等的对象,进行了重复添加。但是看下面的程序:
import java.util.*;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()对两次建立的new Student(1,"zhangsan")对象进行比较时,生成的是不同的哈希码值,所以hashset把他当作不同的对象对待了,当然此时的equals()方法返回的值也不等(这个不用解释了吧)。那么为什么会生成不同的哈希码值呢?上面我们在比较s1和s2的时候不是生成了同样的哈希码吗?原因就在于我们自己写的Student类并没有重新自己的hashcode()和equals()方法,所以在比较时,是继承的object类中的hashcode()方法,呵呵,各位还记得object类中的hashcode()方法比较的是什么吧!!它是一个本地方法,比较的是对象的地址(引用地址),使用new方法创建对象,两次生成的当然是不同的对象了(这个大家都能理解吧。。。),造成的结果就是两个对象的hashcode()返回的值不一样。所以根据第一个准则,hashset会把它们当作不同的对象对待,自然也用不着第二个准则进行判定了。那么怎么解决这个问题呢??答案是:在Student类中重新hashcode()和equals()方法。例如:
 class Student{int num;String name;Student(int num,String name){            this.num=num;            this.name=name;}public int 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(),获得的哈希码肯定是一样的(这一点应该没有疑问吧)。当然根据equals()方法我们也可判断是相同的。所以在向hashset集合中添加时把它们当作重复元素看待了。所以运行修改后的程序时,我们会发现运行结果是:
1:zhangsan
3:wangwu
2:lisi
可以看到重复元素的问题已经消除。关于在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()方法后才能进行判断是否重复,这当然会引起效率的大大降低。我有一个问题,如果像前面提到的在hashset中判断元素是否重复的必要方法是equals()方法(根据网上找到的观点),但是这里并没有涉及到关于哈希表的问题,可是这个集合却叫hashset,这是为什么??我想,在hashmap,hashtable中的存储操作,依然遵守上面的准则。所以这里不再多说。这些是今天看书,网上查询资料,自己总结出来的,部分代码和语言是引述,但是千真万确是自己总结出来的。有错误之处和不详细不清楚的地方还请大家指出,我也是初学者,所以难免会有错误的地方,希望大家共同讨论。