hashcode和equals

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 

以上这个示例，我们只是重写了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 

从结果我们可以看出，现在两个对象就完全相等了，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; 
    } 
}