谈谈hashcode和equals的用法

HASH:

Hash是散列的意思，就是把任意长度的输入，通过散列算法变换成固定长度的输出，该输出就是散列值。关于散列值，有以下几个关键结论：

1、如果散列表中存在和散列原始输入K相等的记录，那么K必定在f(K)的存储位置上

2、不同关键字经过散列算法变换后可能得到同一个散列地址，这种现象称为碰撞

3、如果两个Hash值不同（前提是同一Hash算法），那么这两个Hash值对应的原始输入必定不同

几种常见的hash算法：

（1) MD4

　　MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。它适用在32位字长的处理器上用高速软件实现--它是基于 32 位操作数的位操作来实现的。

（2) MD5

　　MD5(RFC 1321)是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组，其输出是4个32位字的级联，与 MD4 相同。MD5比MD4来得复杂，并且速度较之要慢一点，但更安全，在抗分析和抗差分方面表现更好

（3) SHA-1 及其他

　　SHA1是由NIST NSA设计为同DSA一起使用的，它对长度小于264的输入，产生长度为160bit的散列值，因此抗穷举(brute-force)性更好。SHA-1 设计时基于和MD4相同原理,并且模仿了该算法。

equals的使用：

在Java语言中，equals方法在使用时：

针对包装对象，比较的是对象的值（包括 boolean，byte，char，short，int，long，float，double）

针对String对象，比较的也是String的值（因为String内部重写了equals方法和hashCode方法）

针对其他object对象，比较的是两个对象的引用是否指向同一个内存地址

hashcode:

1、HashCode的存在主要是为了查找的快捷性，在对象存储的散列表里面，hashCode用来指定对象存储的内存地址。而equals用来判断对象的引用是否指向同一个地址，也就是判断两个对象的hashCode值是否一致

2、如果两个对象equals相等，那么这两个对象的HashCode一定也相同

3、如果对象的equals方法被重写，那么对象的HashCode方法也尽量重写

4、如果两个对象的HashCode相同，不代表两个对象就相同，只能说明这两个对象在散列存储结构中，存放于同一个位置

再归纳一下就是hashCode是用于查找使用的，而equals是用于比较两个对象的是否相等的。

hashcode作用：

1.hashcode是用来查找的，提高我们的查询效率。
如果你学过数据结构就应该知道，在查找和排序这一章有
例如内存中有这样的位置
0  1  2  3  4  5  6  7
而我有个类，这个类有个字段叫ID,我要把这个类存放在以上8个位置之一，如果不用hashcode而任意存放，那么当查找时就需要到这八个位置里挨个去找，或者用二分法一类的算法。
但如果用hashcode那就会使效率提高很多。
我们这个类中有个字段叫ID,那么我们就定义我们的hashcode为ID％8，然后把我们的类存放在取得得余数那个位置。比如我们的ID为9，9除8的余数为1，那么我们就把该类存在1这个位置，如果ID是13，求得的余数是5，那么我们就把该类放在5这个位置。这样，以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。  

2.hashcode规定，如果两个类的HashCode都不相同，那么这两个类必定是不同的。用在hashset结构中，就可以大大减少实际调用equals方法的次数，提高效率。
但是如果两个类有相同的hashcode怎么办那（我们假设上面的类的ID不是唯一的），例如9除以8和17除以8的余数都是1，那么这是不是合法的，回答是：可以这样。那么如何判断呢？在这个时候就需要定义 equals了。
也就是说，我们先通过 hashcode来判断两个类是否存放某个桶里，但这个桶里可能有很多类，那么我们就需要再通过 equals 来在这个桶里找到我们要的类。
那么。重写了equals()，为什么还要重写hashCode()呢？
想想，你要在一个桶里找东西，你必须先要找到这个桶啊，你不通过重写hashcode()来找到桶，光重写equals()有什么用啊

　　为什么重写Object的equals(Object obj)方法尽量要重写Object的hashCode()方法?

具体事例：

public class HashTest {
    private int i;  

    public int getI() {
        return i;
    }  

    public void setI(int i) {
        this.i = i;
    }  

    public int hashCode() {
        return i % 10;
    }  

    public final static void main(String[] args) {
        HashTest a = new HashTest();
        HashTest b = new HashTest();
        a.setI(1);
        b.setI(1);
        Set<HashTest> set = new HashSet<HashTest>();
        set.add(a);
        set.add(b);
        System.out.println(a.hashCode() == b.hashCode());
        System.out.println(a.equals(b));
        System.out.println(set);
    }
}

　　输出结果：

true
false
[com.ubs.sae.test.HashTest@1, com.ubs.sae.test.HashTest@1]

　　以上这个示例，我们只是重写了hashCode方法，从上面的结果可以看出，虽然两个对象的hashCode相等，但是实际上两个对象并不是相等；，我们没有重写equals方法，那么就会调用object默认的equals方法，是比较两个对象的引用是不是相同，显示这是两个不同的对象，两个对象的引用肯定是不定的。这里我们将生成的对象放到了HashSet中，而HashSet中只能够存放唯一的对象，也就是相同的（适用于equals方法）的对象只会存放一个，但是这里实际上是两个对象a,b都被放到了HashSet中，这样HashSet就失去了他本身的意义了。

此时我们把equals方法给加上：

public class HashTest {
    private int i;  

    public int getI() {
        return i;
    }  

    public void setI(int i) {
        this.i = i;
    }  

    <span style="color:#3366FF;"><strong>public boolean equals(Object object) {
        if (object == null) {
            return false;
        }
        if (object == this) {
            return true;
        }
        if (!(object instanceof HashTest)) {
            return false;
        }
        HashTest other = (HashTest) object;
        if (other.getI() == this.getI()) {
            return true;
        }
        return false;
    }</strong></span>  

    public int hashCode() {
        return i % 10;
    }  

    public final static void main(String[] args) {
        HashTest a = new HashTest();
        HashTest b = new HashTest();
        a.setI(1);
        b.setI(1);
        Set<HashTest> set = new HashSet<HashTest>();
        set.add(a);
        set.add(b);
        System.out.println(a.hashCode() == b.hashCode());
        System.out.println(a.equals(b));
        System.out.println(set);
    }
}

　　此时得到的结果就会如下：

true
true
[com.ubs.sae.test.HashTest@1]

　　从结果我们可以看出，现在两个对象就完全相等了，HashSet中也只存放了一份对象。

关于String的hashCode方法

要注意的是，String重写了hashCode方法。这是因为散列表（hash表）操作中费时多的部分就是计算hashCode方法，所以在String类中的hashCode方法包含一个重要的优化：每个String对象内部都存储了它的hashCode值，该值初始为0，但如果hashCode方法被调用，那么这个值就将会被记住，下一次使用的时候可以直接调用出来，而不用再计算一次。之所以能这样实现，是由于String类是不可改变的。所以hashCode值被计算之后也并不会发生变化。

String类的hashCode的实现，简要摘录如下：

public final class String{  

    private int hash = 0;  

    public int hashCode(){
        if(hash != 0){
            return hash;
        }  

        for(int i=0; i<length(); i++){
            hash = hash * 31 + (int) charAt(i);
        }
        return hash;
    }
}