core java（六）hascode和equals的原理和用法

hashCode()和equals()定义在Object类中，这个类是所有java类的基类，所以所有的java类都继承这两个方法。

使用hashCode()和equals()

hashCode()方法被用来获取给定对象的唯一整数。这个整数被用来确定对象被存储在HashTable类似的结构中的位置
（也就是说这个整数确认了这个对象的存储位置或者与之相关）。默认的，Object类的hashCode()方法返回这个对象存储的内存地址的编号。

重写默认的实现

如果你不重写这两个方法，将几乎不遇到任何问题，但是有的时候程序要求我们必须改变一些对象的默认实现。

来看看这个例子，让我们创建一个简单的类Employee：

public class Employee{    private Integer id;    private String firstname;    private String lastName;    private String department;    public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public String getFirstname() {        return firstname;    }    public void setFirstname(String firstname) {        this.firstname = firstname;    }    public String getLastName() {        return lastName;    }    public void setLastName(String lastName) {        this.lastName = lastName;    }    public String getDepartment() {        return department;    }    public void setDepartment(String department) {        this.department = department;    }}

上面的Employee类只是有一些非常基础的属性和getter、setter.现在来考虑一个你需要比较两个employee的情形。

public class EqualsTest {    public static void main(String[] args) {        Employee e1 = new Employee();        Employee e2 = new Employee();        e1.setId(100);        e2.setId(100);        //Prints false in console        System.out.println(e1.equals(e2));    }}

毫无疑问的，上面的逻辑输出的是false，但是，事实上上面两个对象代表的是通过一个employee。真正的商业逻辑希望我们返回true。
为了达到这个目的，我们需要重写equals方法。 

public boolean equals(Object o) {        if(o == null)        {            return false;        }        if (o == this)        {           return true;        }        if (getClass() != o.getClass())        {            return false;        }        Employee e = (Employee) o;        return (this.getId() == e.getId());}

在上面的类中添加这个方法，EauqlsTest将会输出true。
So are we done?没有，让我们换一种测试方法来看看。

import java.util.HashSet;import java.util.Set;public class EqualsTest{public static void main(String[] args){Employee e1 = new Employee();Employee e2 = new Employee();e1.setId(100);e2.setId(100);//Prints 'true'System.out.println(e1.equals(e2));Set<Employee> employees = new HashSet<Employee>();employees.add(e1);employees.add(e2);//Prints two objectsSystem.out.println(employees);}

上面的程序输出的结果是两个。如果两个employee对象equals返回true，Set中应该只存储一个对象才对，问题在哪里呢？
我们忘掉了第二个重要的方法hashCode()。就像JDK的Javadoc中所说的一样，如果重写equals()方法必须要重写hashCode()方法。
我们加上下面这个方法，程序将执行正确。

@Overridepublic int hashCode(){final int PRIME = 31;int result = 1;result = PRIME * result + getId();return result;}

使用Apache Commons Lang包重写hashCode() 和equals()方法
Apache Commons 包提供了两个非常优秀的类来生成hashCode()和equals()方法。看下面的程序：

import org.apache.commons.lang3.builder.EqualsBuilder;import org.apache.commons.lang3.builder.HashCodeBuilder;public class Employee{private Integer id;private String firstname;private String lastName;private String department;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getFirstname() {return firstname;}public void setFirstname(String firstname) {this.firstname = firstname;}public String getLastName() {return lastName;}public void setLastName(String lastName) {this.lastName = lastName;}public String getDepartment() {return department;}public void setDepartment(String department) {this.department = department;}@Overridepublic int hashCode(){final int PRIME = 31;return new HashCodeBuilder(getId()%2==0?getId()+1:getId(), PRIME).toHashCode();}@Overridepublic boolean equals(Object o) {if (o == null)return false;if (o == this)return true;if (o.getClass() != getClass())return false;Employee e = (Employee) o;return new EqualsBuilder().append(getId(), e.getId()).isEquals();}}

在eclipse中还是有自动的生成hascode（）或者equals方法的。
原文的链接：点击打开链接

几个疑问的地方：
1.什么时间改写equals() ?
当一个类有自己特有的“逻辑相等”概念（不同于对象身份的概念）。

1.1 java的设计者为啥要搞出个hashCode()方法，一个equals()不是足够了吗？

这个是两个不同功能，或者说所起的作用不同的方法。不存在重复的，也就是说只有一个equals（）是不行的。

观点1：

hash code跟内存没有关系，只不过是Object的默认hashCode()方法会返回一个内存编号，因为这样一定满足hashCode()方法的要求。
hashCode()方法要求：

当对象状态未改变，那么多次调用返回的值必须相等
两个对象equal，那么对象调用返回的值必须相等

一种错误的常规思维是认为hash code跟内存相关联，实际上不是，你可以理解为一个数字标识当前对象状态。

观点2：
hashcode主要是set集合使用，是用于判断对象是否”可能“相等的快捷办法，以解决大集合的问题。举例来说，
如果一个一万个元素的集合加入一个元素，如果是一个新元素，那么必须要equal一万次才能加入。
所以采用hashcode，hashcode的思路是如果equal，则hashcode一定要相等，反过来则不一定；
所以如果hashcode不相等，那么一定不equal，这跟md5的hash来判别密码是一个道理。
hashcode用64位整数，这样可以建立一个索引，新加入元素，先判断这个新元素的hashcode是否存在，
如果不存在，肯定不相等，加入set中；如果存在，则与已有的hashcode的若干个元素比较，这样大大简化了set的equal操作。

观点3：
如果两个对象==，那么一定equal，然后一定要hashcode相等。
而默认的实现是三个方法都采用了比较地址的方法，也就是三个其实都是等价的。
所以，改写了equal，扩大了equal的情况范围，那么必须要同步扩大hashcode的相等范围，
以维持”==则equal，equal则hashcode相等“的逻辑。

2.equals改写了以后为什么要改写hascode（）？
主要原因是默认从Object继承来的hashCode是基于对象的ID实现的。
如果你重载了equals，比如说是基于对象的内容实现的，而保留hashCode的实现不变，那么很可能某两个对象明明是“相等”，而hashCode却不一样。
这样，当你用其中的一个作为键保存到hashMap、hasoTable或hashSet中，再以“相等的”找另一个作为键值去查找他们的时候，则根本找不到。
——而这是反直觉的，因为“我要找的就是那个相等的对象，他明明在，我却找不到”。

如果两个对象相等，那么他们的hascode一定是相等吗？
一定是相等的。这个是一个java的规定。

但是如果hascode相等，那么两个对象是不是相等那？hashMap的存储机制告诉我们这个可能是不相等的。


3.hascode（）里面的实现代码：

public int hashCode() { int h = hash; int len = count; if (h == 0 && len > 0) { int off = offset; char val[] = value; for (int i = 0; i < len; i++) { h = 31*h + val[off++]; } hash = h; } return h; } 

为什么要使用31这个数字？？

A.31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终的出来的结果只能被素数本身和被乘数还有1来整除！。(减少冲突)

B.因为任何数n * 31就可以被JVM优化为 (n << 5) - n移位和减法的操作效率要比乘法的操作效率高的多，对左移现在很多虚拟机里面都有做相关优化。

C.选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）

D.并且31只占用5bits,相乘造成数据溢出的概率较小。

4.如何覆写equals()和hascode（）？

覆写equals方法

1 使用instanceof操作符检查“实参是否为正确的类型”。
2 对于类中的每一个“关键域”，检查实参中的域与当前对象中对应的域值。
3. 对于非float和double类型的原语类型域，使用==比较；
4 对于对象引用域，递归调用equals方法；
5 对于float域，使用Float.floatToIntBits(afloat)转换为int，再使用==比较；
6 对于double域，使用Double.doubleToLongBits(adouble)转换为int，再使用==比较；
7 对于数组域，调用Arrays.equals方法。

覆写hashcode

1. 把某个非零常数值，例如17，保存在int变量result中；
2. 对于对象中每一个关键域f（指equals方法中考虑的每一个域）：
boolean型，计算(f? 0 : 1);
byte,char,short型，计算(int);
long型，计算(int)(f ^ (f>>>32));
float型，计算Float.floatToIntBits(afloat);
double型，计算Double.doubleToLongBits(adouble)得到一个long，再执行[2.3];
对象引用，递归调用它的hashCode方法;
数组域，对其中每个元素调用它的hashCode方法。
将上面计算得到的散列码保存到int变量c，然后执行result=37*result+c;
返回result。