笔记-HashCode

什么是HashCode

hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值

Object中hashCode方法

public int hashCode()返回该对象的哈希码值。支持此方法是为了提高哈希表（例如 java.util.Hashtable 提供的哈希表）的性能。

hashCode常规协定

一致性

在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。

equals

如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果，注：这里说的equals(Object) 方法是指Object类中未被子类重写过的equals方法。

附加

如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

hashcode和hashMap

HashMap对象是根据其Key的hashCode来获取对应的Value。

在重写父类的equals方法时，也重写hashcode方法，使相等的两个对象获取的HashCode也相等，这样当此对象做Map类中的Key时，两个equals为true的对象其获取的value都是同一个，比较符合实际。

 

 

以下是详细例子，转载自diqye2011的博客，参考地址：http://blog.csdn.net/diqye2011/article/details/7641406

 

HashCode和HashMap  HashTable

 

先看看Java中的HashCode　

在Java中，哈希码代表对象的特征。

　　例如对象 String str1 = “aa”, str1.hashCode= 3104
　　String str2 = “bb”, str2.hashCode= 3106
　　String str3 = “aa”, str3.hashCode= 3104
　　根据HashCode由此可得出str1!=str2,str1==str3
　　哈希码产生的依据：哈希码并不是完全唯一的，它是一种算法，让同一个类的对象按照自己不同的特征尽量的有不同的哈希码，但不表示不同的对象哈希码完全不同。也有相同的情况，看程序员如何写哈希码的算法。
　　下面给出几个常用的哈希码的算法。
　　1：Object类的hashCode.返回对象的内存地址经过处理后的结构，由于每个对象的内存地址都不一样，所以哈希码也不一样。
　　2：String类的hashCode.根据String类包含的字符串的内容，根据一种特殊算法返回哈希码，只要字符串内容相同，返回的哈希码也相同。

　　3：Integer类，返回的哈希码就是Integer对象里所包含的那个整数的数值，例如Integer i1=new Integer(100),i1.hashCode的值就是100 。由此可见，2个一样大小的Integer对象，返回的哈希码也一样。更多资料请参考这里

类 HashMap<K,V>

java.lang.Object  java.util.AbstractMap<K,V>      java.util.HashMap<K,V>

类型参数：

K - 此映射所维护的键的类型

V - 所映射值的类型

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用null 值和null 键。（除了非同步和允许使用 null 之外，HashMap 类与Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

HashCode和HashMap之间的关系

先如下代码:

import java.util.HashMap;  

1. public class Test {  
2.   
3.     //重写Equals不重写HashCode  
4.     static class Key {  
5.         private Integer id;  
6.         private String value;  
7.           
8.         public Key(Integer id, String value) {  
9.             super();  
10.             this.id = id;  
11.             this.value = value;  
12.         }  
13.         @Override  
14.         public boolean equals(Object o) {  
15.             if(o == null || !(o instanceof Key)) {  
16.                 return false;  
17.             }else {  
18.                 return this.id.equals(((Key)o).id);  
19.             }  
20.         }  
21.     }  
22.     //重写Equals也重写HashCode  
23.         static class Key_ {  
24.             private Integer id;  
25.             private String value;  
26.               
27.             public Key_(Integer id, String value) {  
28.                 super();  
29.                 this.id = id;  
30.                 this.value = value;  
31.             }  
32.             @Override  
33.             public boolean equals(Object o) {  
34.                 if(o == null || !(o instanceof Key_)) {  
35.                     return false;  
36.                 }else {  
37.                     return this.id.equals(((Key_)o).id);  
38.                 }  
39.             }  
40.             @Override  
41.             public int hashCode() {  
42.                  return id.hashCode();  
43.             }  
44.                
45.         }  
46.     public static void main(String[] args) {  
47.         //test hashcode  
48.         HashMap<Object, String> values = new HashMap<Object, String>(5);  
49.         Test.Key key1 =   new Test.Key(1, "one");  
50.         Test.Key key2 =   new Test.Key(1, "one");  
51.         System.out.println(key1.equals(key2));  
52.         values.put(key1, "value 1");  
53.         System.out.println(values.get(key2));  
54.           
55.         Test.Key_ key_1 =   new Test.Key_(1, "one");  
56.         Test.Key_ key_2 =   new Test.Key_(1, "one");  
57.         System.out.println(key_1.equals(key_2));  
58.         System.out.println(key_1 == key_2);  
59.         values.put(key_1, "value 1");  
60.         System.out.println(values.get(key_2));  
61.     }  
62. }  

import java.util.HashMap;public class Test {//重写Equals不重写HashCodestatic class Key {private Integer id;private String value;public Key(Integer id, String value) {super();this.id = id;this.value = value;}@Overridepublic boolean equals(Object o) {if(o == null || !(o instanceof Key)) {return false;}else {return this.id.equals(((Key)o).id);}}}//重写Equals也重写HashCodestatic class Key_ {private Integer id;private String value;public Key_(Integer id, String value) {super();this.id = id;this.value = value;}@Overridepublic boolean equals(Object o) {if(o == null || !(o instanceof Key_)) {return false;}else {return this.id.equals(((Key_)o).id);}}@Overridepublic int hashCode() { return id.hashCode();} }public static void main(String[] args) {//test hashcodeHashMap<Object, String> values = new HashMap<Object, String>(5);Test.Key key1 =   new Test.Key(1, "one");Test.Key key2 =   new Test.Key(1, "one");System.out.println(key1.equals(key2));values.put(key1, "value 1");System.out.println(values.get(key2));Test.Key_ key_1 =   new Test.Key_(1, "one");Test.Key_ key_2 =   new Test.Key_(1, "one");System.out.println(key_1.equals(key_2));System.out.println(key_1 == key_2);values.put(key_1, "value 1");System.out.println(values.get(key_2));}}

输出如下:由上述例子可见:只重写了equasl方法的Key类 在用做Hash中的键值的时候 两个equasl为true的对象不能获取相应 的Value的而重写了hashCode方法和equals方法的key_类 两个相等的对象 可以获取同一个Value的,这样更符合生活中 的逻辑HashMap对象是根据Key的hashCode来获取对应的Vlaue 因而两个HashCode相同的对象可以获取同一个Value

参考资料

• 1．  哈希码 ．百度百科

• 2．  hashCode和hashMap ．CSDN