前言
Object提供给我们了一个Native的方法“public native int hashCode();”，本文讲讲Hash是什么以及HashCode的作用
Hash
先用一张图看下什么是Hash
Hash是散列的意思，就是把任意长度的输入，通过散列算法变换成固定长度的输出，该输出就是散列值。关于散列值，有以下几个关键结论：
1、如果散列表中存在和散列原始输入K相等的记录，那么K必定在f(K)的存储位置上
2、不同关键字经过散列算法变换后可能得到同一个散列地址，这种现象称为碰撞
3、如果两个Hash值不同（前提是同一Hash算法），那么这两个Hash值对应的原始输入必定不同
HashCode
然后讲下什么是HashCode，总结几个关键点：
1、HashCode的存在主要是为了查找的快捷性，HashCode是用来在散列存储结构中确定对象的存储地址的
2、如果两个对象equals相等，那么这两个对象的HashCode一定也相同
3、如果对象的equals方法被重写，那么对象的HashCode方法也尽量重写
4、如果两个对象的HashCode相同，不代表两个对象就相同，只能说明这两个对象在散列存储结构中，存放于同一个位置
HashCode有什么用
回到最关键的问题，HashCode有什么用？不妨举个例子：
1、假设内存中有0 1 2 3 4 5 6 7 8这8个位置，如果我有个字段叫做ID，那么我要把这个字段存放在以上8个位置之一，如果不用HashCode而任意存放，那么当查找时就需要到8个位置中去挨个查找
2、使用HashCode则效率会快很多，把ID的HashCode%8，然后把ID存放在取得余数的那个位置，然后每次查找该类的时候都可以通过ID的HashCode%8求余数直接找到存放的位置了
3、如果ID的HashCode%8算出来的位置上本身已经有数据了怎么办？这就取决于算法的实现了，比如ThreadLocal中的做法就是从算出来的位置向后查找第一个为空的位置，放置数据；HashMap的做法就是通过链式结构连起来。反正，只要保证放的时候和取的时候的算法一致就行了。
4、如果ID的HashCode%8相等怎么办（这种对应的是第三点说的链式结构的场景）？这时候就需要定义equals了。先通过HashCode%8来判断类在哪一个位置，再通过equals来在这个位置上寻找需要的类。对比两个类的时候也差不多，先通过HashCode比较，假如HashCode相等再判断equals。如果两个类的HashCode都不相同，那么这两个类必定是不同的。
举个实际的例子Set。我们知道Set里面的元素是不可以重复的，那么如何做到？Set是根据equals()方法来判断两个元素是否相等的。比方说Set里面已经有1000个元素了，那么第1001个元素进来的时候，最多可能调用1000次equals方法，如果equals方法写得复杂，对比的东西特别多，那么效率会大大降低。使用HashCode就不一样了，比方说HashSet，底层是基于HashMap实现的，先通过HashCode取一个模，这样一下子就固定到某个位置了，如果这个位置上没有元素，那么就可以肯定HashSet中必定没有和新添加的元素equals的元素，就可以直接存放了，都不需要比较；如果这个位置上有元素了，逐一比较，比较的时候先比较HashCode，HashCode都不同接下去都不用比了，肯定不一样，HashCode相等，再equals比较，没有相同的元素就存，有相同的元素就不存。如果原来的Set里面有相同的元素，只要HashCode的生成方式定义得好（不重复），不管Set里面原来有多少元素，只需要执行一次的equals就可以了。这样一来，实际调用equals方法的次数大大降低，提高了效率。
为什么重写Object的equals(Object obj)方法尽量要重写Object的hashCode()方法
我们在重写Object的equals(Object obj)方法的时候，应该尽量重写hashCode()方法，这是有原因的，下面详细解释下：
1 public class HashCodeClass 2 { 3 private String str0; 4 private double dou0; 5 private int int0; 6 7 public boolean equals(Object obj) 8 { 9 if (obj instanceof HashCodeClass) 10 { 11 HashCodeClass hcc = (HashCodeClass)obj; 12 if (hcc.str0.equals(this.str0) && 13 hcc.dou0 == this.dou0 && 14 hcc.int0 == this.int0) 15 { 16 return true; 17 } 18 return false; 19 } 20 return false; 21 } 22 }
1 public class TestMain 2 { 3 public static void main(String[] args) 4 { 5 System.out.println(new HashCodeClass().hashCode()); 6 System.out.println(new HashCodeClass().hashCode()); 7 System.out.println(new HashCodeClass().hashCode()); 8 System.out.println(new HashCodeClass().hashCode()); 9 System.out.println(new HashCodeClass().hashCode()); 10 System.out.println(new HashCodeClass().hashCode()); 11 } 12 }
打印出来的值是：
1901116749 1807500377 355165777 1414159026 1569228633 778966024
我们希望两个HashCodeClass类equals的前提是两个HashCodeClass的str0、dou0、int0分别相等。OK，那么这个类不重写hashCode()方法是有问题的。
现在我的HashCodeClass都没有赋初值，那么这6个HashCodeClass应该是全部equals的。如果以HashSet为例，HashSet内部的HashMap的table本身的大小是16，那么6个HashCode对16取模分别为13、9、1、2、9、8。第一个放入table[13]的位置、第二个放入table[9]的位置、第三个放入table[1]的位置。。。但是明明是全部equals的6个HashCodeClass，怎么能这么做呢？HashSet本身要求的就是equals的对象不重复，现在6个equals的对象在集合中却有5份（因为有两个计算出来的模都是9）。
那么我们该怎么做呢？重写hashCode方法，根据str0、dou0、int0搞一个算法生成一个尽量唯一的hashCode，这样就保证了str0、dou0、int0都相等的两个HashCodeClass它们的HashCode是相等的，这就是重写equals方法必须尽量要重写hashCode方法的原因。看下JDK中的一些类，都有这么做：
Integer的
1 public int hashCode() { 2 return value; 3 } 4 5 public boolean equals(Object obj) { 6 if (obj instanceof Integer) { 7 return value == ((Integer)obj).intValue(); 8 } 9 return false; 10 }
String的
1 public int hashCode() { 2 int h = hash; 3 if (h == 0) { 4 int off = offset; 5 char val[] = value; 6 int len = count; 7 8 for (int i = 0; i < len; i++) { 9 h = 31*h + val[off++]; 10 } 11 hash = h; 12 } 13 return h; 14 } 15 16 public boolean equals(Object anObject) { 17 if (this == anObject) { 18 return true; 19 } 20 if (anObject instanceof String) { 21 String anotherString = (String)anObject; 22 int n = count; 23 if (n == anotherString.count) { 24 char v1[] = value; 25 char v2[] = anotherString.value; 26 int i = offset; 27 int j = anotherString.offset; 28 while (n-- != 0) { 29 if (v1[i++] != v2[j++]) 30 return false; 31 } 32 return true; 33 } 34 } 35 return false; 36 }
HashMap中的实体类Entry
public final int hashCode() { return (key==null ? 0 : key.hashCode()) ^ (value==null ? 0 : value.hashCode()); } public final boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry e = (Map.Entry)o; Object k1 = getKey(); Object k2 = e.getKey(); if (k1 == k2 || (k1 != null && k1.equals(k2))) { Object v1 = getValue(); Object v2 = e.getValue(); if (v1 == v2 || (v1 != null && v1.equals(v2))) return true; } return false; }
哈希码
哈希码具体是什么？
答：hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值
常见的哈希码的算法有：
1：Object类的hashCode.返回对象的内存地址经过处理后的结构，由于每个对象的内存地址都不一样，所以哈希码也不一样。
2：String类的hashCode.根据String类包含的字符串的内容，根据一种特殊算法返回哈希码，只要字符串内容相同，返回的哈希码也相同。
3：Integer类，返回的哈希码就是Integer对象里所包含的那个整数的数值，例如Integer i1=new Integer(100),i1.hashCode的值就是100 。
跟踪Object类的native方法hashCode方法从jvm源码中得到了下面的一些内容，供参考。
Object中hashCode方法是一个本地方法：public native inthashCode();
对于Java HotSpot VM，首先介绍一个概念就是对象的header,
每个对象都会有一个header，header由两个机器字表示(8个字节对于32位架构，16个字节对于64位架构)。
header的第一个字中有7位用做同步及垃圾收集，另外25位存储对象的hash码。
header的第二个字存储指向对应Class对象的指针(Class对象用来保存类的元数据信息及方法表)。
hashcode 作用 ：对象实例的唯一标识
在同一运行环境下 hashcode 的值是唯一的
就是两个不同实例其hashcode在同一运行环境绝对不一样 主要用来区分 两个实例在物理上是不是同一个对象。
如：
string a ="111";
string b ="111";
a和b 的hashcode是一样的。
其原因是Java的字符串池优化原因，你声明一个字符串时JVM会先去查找 字符串池 是否有相同字符串有将已经有的字符串对象的引用返回 而不是新生成一个字符对象到内存没有 新生成 并将其引用放入字符串池 如此循环所以他们是同一个对象 其hashcode也一样
至于这个
String a = newString("i love you");
String b = newString("i love you");
如果hashcode也一样的话 那他们应该也是类似的优化。jdk5 好像不一样吧？
hashcode（）是要在容器里面的MAP这个才能体现其价值，在MAP里面要是重写equals,就要重写hashcode的方法，只要equals为真，那么hashcode也应该一样。平时其他的使用hashcode没什么大用。
对于Object对象来说，不同的Object对象的hashcode是不同的，它们返回的是对象的地址，equals返回的也是对象的地址。
所以在自己定义的类中如果要添加到集合对象中，最好是要重写hashcode和equals方法，不然会自动继承自Object类中的两个方法根据对象地址来判断。在重写自己定义的类时，通常是在类中的根据某个值如name.hashcode();来进行判断。
一般来讲，equals这个方法是给用户调用的，如果你想判断2个对象是否相等，你可以重写equals方法，然后在代码中调用，就可以判断他们是否相等了。简单来讲，equals方法主要是用来判断从表面上看或者从内容上看，2个对象是不是相等。举个例子，有个学生类，属性只有姓名和性别，那么我们可以认为只要姓名和性别相等，那么就说这2个对象是相等的。
hashcode方法一般用户不会去调用，比如在hashmap中，由于key是不可以重复的，他在判断key是不是重复的时候就判断了hashcode这个方法，而且也用到了equals方法。这里不可以重复是说equals和hashcode只要有一个不等就可以了！所以简单来讲，hashcode相当于是一个对象的编码，就好像文件中的md5，他和equals不同就在于他返回的是int型的，比较起来不直观。我们一般在覆盖equals的同时也要覆盖hashcode，让他们的逻辑一致。举个例子，还是刚刚的例子，如果姓名和性别相等就算2个对象相等的话，那么hashcode的方法也要返回姓名的hashcode值加上性别的hashcode值，这样从逻辑上，他们就一致了。
要从物理上判断2个对象是否相等，用==就可以了。
"=="和equals方法究竟有什么区别？
==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。
如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：
String a=new String("foo");
String b=new String("foo");
两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。
在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。
如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：
boolean equals(Object o){
return this==o;
}
这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。
272
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
