Java中的equals() 和 hashCode() 详解

一 equals()方法详解

        equals() 的作用是 用来判断两个对象是否相等。

        用来判断两个对象是否相同，在Object类中是通过判断对象间的内存地址来决定是否相同

        equals() 定义在Object中，用来判断两个对象是否相同     源码如下：

public boolean equals(Object obj) {
    return (this == obj);
}

        由此可以看到，默认的“equals()”方法，等价于“==”方法是通过判断对象间的内存地址来决定是否相同， 所以要进行重写。

         比如在String类中如下：

public boolean equals(Object anObject) {  
    if (this == anObject) {  
        return true;  
    }  
    if (anObject instanceof String) {  
        String anotherString = (String)anObject;  
        int n = count;  
        if (n == anotherString.count) {  
            char v1[] = value;  
            char v2[] = anotherString.value;  
            int i = offset;  
            int j = anotherString.offset;  
            while (n– != 0) {  
                if (v1[i++] != v2[j++])  
                    return false;  
            }  
            return true;  
        }  
    }  
    return false;  
}  

        可以看到现在是进行的内容比较，而已经不再是地址的比较。

        需要注意的是当equals()方法被重写时，hashCode()也要被重写。按照hashCode()方法的实现来说，相等的对象，它们的hash code一定相等。

java对equals()重写的要求。有以下几点：

        自反性（reflexive）。对于任意不为null的引用值x，x.equals(x)一定是true。

        对称性（symmetric）。对于任意不为null的引用值x和y，当且仅当x.equals(y)是true时，y.equals(x)也是true。

        传递性（transitive）。对于任意不为null的引用值x、y和z，如果x.equals(y)是true，同时y.equals(z)是true，那么x.equals(z)一定是true。

        一致性（consistent）。对于任意不为null的引用值x和y，如果用于equals比较的对象信息没有被修改的话，多次调用时x.equals(y)要么一致地返回true要么一致地返回false。

   非空性，x.equals(null)，永远返回是"false"；x.equals(和x不同类型的对象)永远返回是"false"。

二 hashcode() 方法详解

        hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置;

        hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

        上面的散列表，指的是：Java集合中本质是散列表的类，如HashMap，Hashtable，HashSet。

        由Object类定义的hashCode()方法对于不同的对象返回不同的integer。

        在object类中，hashCode定义如下：

public native int hashCode();

        可以看到hashCode是一个本地方法，它的实现是根据本地机器相关的。当然我们可以在自己写的类中重写hashcode()方法；

        比如String、Integer、Double等这些类都是重写了hashcode()方法的。例如在String类中定义的hashcode()方法如下：

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

String的API中写到：s[0]*31^(n-1) + s[1]*31^(n-2) + … + s[n-1]
      使用 int 算法，这里 s[i] 是字符串的第 i 个字符，n 是字符串的长度，^ 表示求幂（空字符串的哈希码为 0）

至此，我们搞清楚了：hashCode()的作用是获取散列码。但是，散列码是用来干什么的呢？

        散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！ 散列表的本质是通过数组实现的。当我们要获取散列表中的某个“值”时，实际上是要获取数组中的某个位置的元素。而数组的位置，就是通过“键”来获取的；更进一步说，数组的位置，是通过“键”对应的散列码计算得到的。

以HashSet为例，来深入说明hashCode()的作用。

        假设，HashSet中已经有10000个元素。当插入第10001个元素时，需要怎么处理？因为HashSet是Set集合，它不允许有重复元素。“将第10001个元素逐个的和前面10000个元素进行比较”？显然，这个效率是相等低下的。散列表很好的解决了这个问题，它根据元素的散列码计算出元素在散列表中的位置，然后将元素插入该位置即可。对于相同的元素，自然是只保存了一个。
        由此可知，若两个元素相等，它们的散列码一定相等；但反过来确不一定。在散列表中，
                           1、如果两个对象相等，那么它们的hashCode()值一定要相同；
                           2、如果两个对象hashCode()相等，它们并不一定相等;

概括为以下几点：

      1  该方法返回对象的哈希码，支持该方法是为哈希表提供一些优点，例如，HashMap 提供的哈希表。
      2  同一个对象未发生改变时多次调用hashCode()返回值必须相同，
      3  两个对象equals不相等，那么两对象的hashCode()返回必定不同（此处可用来提高哈希表性能）
       4 两个对象的hashCode()返回值相同，两对象不一定相同，还需要通过equals()再次判断
      5  当equals方法被重写时，通常有必要重写 hashCode 方法

三 hashCode() 和 equals() 的关系

关于第一点，相等（相同）的对象必须具有相等的哈希码（或者散列码），为什么？ 

        假如两个Java对象A和B，A和B相等（eqauls结果为true），但A和B的哈希码不同，则A和B存入HashMap时的哈希码计算得到的HashMap内部数组位置索引可能不同，那么A和B很有可能允许同时存入HashMap，显然相等/相同的元素是不允许同时存入HashMap，HashMap不允许存放重复元素。

关于第二点，两个对象的hashCode相同，它们并不一定相同 为什么？

        不同对象的hashCode可能相同；假如两个Java对象A和B，A和B不相等（eqauls结果为false），但A和B的哈希码相等，将A和B都存入HashMap时会发生哈希冲突，也就是A和B存放在HashMap内部数组的位置索引相同这时HashMap会在该索引位置建立一个链表，将A和B串起来放在该位置，该情况不违反HashMap的使用原则，是允许的。当然，哈希冲突越少越好，尽量采用好的哈希算法以避免哈希冲突。

所以，Java对于eqauls方法和hashCode方法是这样规定的： 

        1.如果两个对象(equals比较返回尾true)相同，那么它们的hashCode值一定要相同；

         2.如果两个对象的hashCode相同，它们并不一定相同（这里说的对象相同指的是用eqauls方法比较）
         3.equals()相等的两个对象，hashcode()一定相等；equals()不相等的两个对象，却并不能证明他们的hashcode()不相等。

        换句话说，equals()方法不相等的两个对象，hashcode()有可能相等（我的理解是由于哈希码在生成的时候产生冲突造成的）。反过来，hashcode()不等，一定能推出equals()也不等；hashcode()相等，equals()可能相等，也可能不等。

           在object类中，hashcode()方法是本地方法，返回的是对象的地址值，而object类中的equals()方法比较的也是两个对象的地址值，如果equals()相等，说明两个对象地址值也相等，当然hashcode()也就相等了；

        在String类中，equals()返回的是两个对象内容的比较，当两个对象内容相等时，Hashcode()方法根据String类的重写代码的分析，也可知道hashcode()返回结果也会相等。以此类推，可以知道Integer、Double等封装类中经过重写的equals()和hashcode()方法也同样适合于这个原则。当然没有经过重写的类，在继承了object类的equals()和hashcode()方法后，也会遵守这个原则。

总结

1. hashCode主要用于提升查询效率提高哈希表性能，来确定在散列结构中对象的存储地址
2. 重写equals()必须重写hashCode()
3. 哈希存储结构中，添加元素重复性校验的标准就是先检查hashCode值，后判断equals()
4. 两个对象equals()相等，hashcode()必定相等
5. 两个对象hashcode()不等，equals()必定也不等
6. 两个对象hashcode()相等，对象不一定相等，需要通过equals()进一步判断。