如何重写hashCode()和equals()方法

hashCode()和equals()方法可以说是Java完全面向对象的一大特色.它为我们的编程提供便利的同时也带来了很多危险.这篇文章我们就讨论一下如何正解理解和使用这2个方法.

如何重写equals()方法

如果你决定要重写equals()方法,那么你一定要明确这么做所带来的风险,并确保自己能写出一个健壮的equals()方法.一定要注意的一点是,在重写equals()后,一定要重写hashCode()方法.具体原因稍候再进行说明.

我们先看看 JavaSE 7 Specification中对equals()方法的说明:

  • It is reflexive: for any non-null reference value xx.equals(x) should return true.
  • It is symmetric: for any non-null reference values x and yx.equals(y) should return true if and only if y.equals(x) returns true.
  • It is transitive: for any non-null reference values xy, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
  • It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
  • For any non-null reference value xx.equals(null) should return false.

这段话用了很多离散数学中的术数.简单说明一下:

1. 自反性:A.equals(A)要返回true.

2. 对称性:如果A.equals(B)返回true, 则B.equals(A)也要返回true.

3. 传递性:如果A.equals(B)为true, B.equals(C)为true, 则A.equals(C)也要为true. 说白了就是 A = B , B = C , 那么A = C.

4. 一致性:只要A,B对象的状态没有改变,A.equals(B)必须始终返回true.

5. A.equals(null) 要返回false.

相信只要不是专业研究数学的人,都对上面的东西不来电.在实际应用中我们只需要按照一定的步骤重写equals()方法就可以了.为了说明方便,我们先定义一个程序员类

1 class Coder {
2     private String name;
3     private int age;
4
5     // getters and setters
6 }  

我们想要的是,如果2个程序员对象的name和age都是相同的,那么我们就认为这两个程序员是一个人.这时候我们就要重写其equals()方法.因为默认的equals()实际是判断两个引用是否指向内在中的同一个对象,相当于 == . 重写时要遵循以下三步:

1. 判断是否等于自身.

1 if(other == this)
2              return true; 

2. 使用instanceof运算符判断 other 是否为Coder类型的对象.

1 if(!(other instanceof Coder))
2             return false;  

3. 比较Coder类中你自定义的数据域,name和age,一个都不能少.

1 Coder o = (Coder)other;
2         return o.name.equals(name) && o.age == age;

看到这有人可能会问,第3步中有一个强制转换,如果有人将一个Integer类的对象传到了这个equals中,那么会不会扔ClassCastException呢?这个担心其实是多余的.因为我们在第二步中已经进行了instanceof 的判断,如果other是非Coder对象,甚至other是个null, 那么在这一步中都会直接返回false, 从而后面的代码得不到执行的机会.

上面的三步也是<Effective Java>中推荐的步骤,基本可保证万无一失.

如何重写hashCode()方法

在JavaSE 7 Specification中指出,

"Note that it is generally necessary to override the hashCode method whenever this method(equals) is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes."

如果你重写了equals()方法,那么一定要记得重写hashCode()方法.我们在大学计算机数据结构课程中都已经学过哈希表(hash table)了,hashCode()方法就是为哈希表服务的.

当我们在使用形如HashMap, HashSet这样前面以Hash开头的集合类时,hashCode()就会被隐式调用以来创建哈希映射关系.稍后我们再对此进行说明.这里我们先重点关注一下hashCode()方法的写法.

<Effective Java>中给出了一个能最大程度上避免哈希冲突的写法,但我个人认为对于一般的应用来说没有必要搞的这么麻烦.如果你的应用中HashSet中需要存放上万上百万个对象时,那你应该严格遵循书中给定的方法.如果是写一个中小型的应用,那么下面的原则就已经足够使用了:

要保证Coder对象中所有的成员都能在hashCode中得到体现.

对于本例,我们可以这么写:

1 @Override
2     public int hashCode() {
3         int result = 17;
4         result = result * 31 + name.hashCode();
5         result = result * 31 + age;
6
7         return result;
8     }  

其中int result = 17你也可以改成20, 50等等都可以.看到这里我突然有些好奇,想看一下String类中的hashCode()方法是如何实现的.查文档知:

"Returns a hash code for this string. The hash code for a String object is computed as

 s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
 

using int arithmetic, where s[i] is the ith character of the string, n is the length of the string, and ^ indicates exponentiation. (The hash value of the empty string is zero.)"

对每个字符的ASCII码计算n - 1次方然后再进行加和,可见Sun对hashCode的实现是很严谨的. 这样能最大程度避免2个不同的String会出现相同的hashCode的情况.

重写equals()而不重写hashCode()的风险

在Oracle的Hash Table实现中引用了bucket的概念.如下图所示:

从上图中可以看出,带bucket的hash table大致相当于哈希表与链表的结合体.即在每个bucket上会挂一个链表,链表的每个结点都用来存放对象.Java通过hashCode()方法来确定某个对象应该位于哪个bucket中,然后在相应的链表中进行查找.在理想情况下,如果你的hashCode()方法写的足够健壮,那么每个bucket将会只有一个结点,这样就实现了查找操作的常量级的时间复杂度.即无论你的对象放在哪片内存中,我都可以通过hashCode()立刻定位到该区域,而不需要从头到尾进行遍历查找.这也是哈希表的最主要的应用.

如:

当我们调用HashSet的put(Object o)方法时,首先会根据o.hashCode()的返回值定位到相应的bucket中,如果该bucket中没有结点,则将 o 放到这里,如果已经有结点了, 则把 o 挂到链表末端.同理,当调用contains(Object o)时,Java会通过hashCode()的返回值定位到相应的bucket中,然后再在对应的链表中的结点依次调用equals()方法来判断结点中的对象是否是你想要的对象.

下面我们通过一个例子来体会一下这个过程:

我们先创建2个新的Coder对象:

1 Coder c1 = new Coder("bruce", 10);
2 Coder c2 = new Coder("bruce", 10); 

假定我们已经重写了Coder的equals()方法而没有重写hashCode()方法:

 1 @Override
 2     public boolean equals(Object other) {
 3         System.out.println("equals method invoked!");
 4
 5         if(other == this)
 6             return true;
 7         if(!(other instanceof Coder))
 8             return false;
 9
10         Coder o = (Coder)other;
11         return o.name.equals(name) && o.age == age;
12     }  

然后我们构造一个HashSet,将c1对象放入到set中:

1 Set<Coder> set = new HashSet<Coder>();
2         set.add(c1);  

再执行:

1  System.out.println(set.contains(c2));  

我们期望contains(c2)方法返回true, 但实际上它返回了false.

c1和c2的name和age都是相同的,为什么我把c1放到HashSet中后,再调用contains(c2)却返回false呢?这就是hashCode()在作怪了.因为你没有重写hashCode()方法,所以HashSet在查找c2时,会在不同的bucket中查找.比如c1放到05这个bucket中了,在查找c2时却在06这个bucket中找,这样当然找不到了.因此,我们重写hashCode()的目的在于,在A.equals(B)返回true的情况下,A, B 的hashCode()要返回相同的值

我让hashCode()每次都返回一个固定的数行吗

有人可能会这样重写:

1 @Override
2     public int hashCode() {
3         return 10;
4
5     } 

如果这样的话,HashMap, HashSet等集合类就失去了其 "哈希的意义".用<Effective Java>中的话来说就是,哈希表退化成了链表.如果hashCode()每次都返回相同的数,那么所有的对象都会被放到同一个bucket中,每次执行查找操作都会遍历链表,这样就完全失去了哈希的作用.所以我们最好还是提供一个健壮的hashCode()为妙.

摘自:http://blog.csdn.net/neosmith/article/details/17068365

时间: 2024-10-23 06:55:01

如何重写hashCode()和equals()方法的相关文章

重写hashCode与equals方法的作用

为了阐明其作用,我们先来假设有如下一个Person类. class Person { public Person(String name, int age) { this.name = name; this.age = age; } private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; }

为什么要重写hashcode和equals方法?初级程序员在面试中很少能说清楚。

我在面试 Java初级开发的时候,经常会问:你有没有重写过hashcode方法?不少候选人直接说没写过.我就想,或许真的没写过,于是就再通过一个问题确认:你在用HashMap的时候,键(Key)部分,有没有放过自定义对象?而这个时候,候选人说放过,于是两个问题的回答就自相矛盾了. 最近问下来,这个问题普遍回答不大好,于是在本文里,就干脆从hash表讲起,讲述HashMap的存数据规则,由此大家就自然清楚上述问题的答案了. 1 通过Hash算法来了解HashMap对象的高效性 我们先复习数据结构里

HashMap中使用自定义类作为Key时,为何要重写HashCode和Equals方法

之前一直不是很理解为什么要重写HashCode和Equals方法,才只能作为键值存储在HashMap中.通过下文,可以一探究竟. 首先,如果我们直接用以下的Person类作为键,存入HashMap中,会发生发生什么情况呢? public class Person { private String id; public Person(String id) { this.id = id; } } import java.util.HashMap; public class Main { public

(转)为什么要重写 hashcode 和 equals 方法?

作者丨hsm_computer cnblogs.com/JavaArchitect/p/10474448.html 我在面试Java初级开发的时候,经常会问:你有没有重写过hashcode方法?不少候选人直接说没写过.我就想,或许真的没写过,于是就再通过一个问题确认:你在用HashMap的时候,键(Key)部分,有没有放过自定义对象?而这个时候,候选人说放过,于是两个问题的回答就自相矛盾了. 最近问下来,这个问题普遍回答不大好,于是在本文里,就干脆从hash表讲起,讲述HashMap的存数据规则

面试官:为什么要重写hashcode和equals方法?

 一个几乎必问的面试题  在面试 Java初级开发的时候,经常会问的一个问题是:你有没有重写过 hashcode方法?不少候选人直接说没写过.或许真的是没写过,于是还可以再通过一个问题确认:你在用HashMap的时候,键( Key)部分,有没有放过自定义对象?而这个时候,候选人说放过,于是两个问题的回答就自相矛盾了. 其实很多人这个问题普遍回答得都不大好,于是在本文里,就干脆 从 hash表讲起,讲述HashMap的存数据规则,由此大家就自然清楚上述问题的答案了.  再过一遍Hash算法  先复

java集合框架(hashSet自定义元素是否相同,重写hashCode和equals方法)

/*HashSet 基本操作 * --set:元素是无序的,存入和取出顺序不一致,元素不可以重复 * (通过哈希值来判断是否是同一个对象) * ----HashSet:底层数据结构是哈希表, * 保证数据唯一性的方法是调用存入元素的hashCode()方法 * 和equals(Object obj)方法 * HashCode值相同,才会调用equals方法 * * */ 1 import java.util.HashSet; 2 import java.util.Iterator; 3 publ

hashcode和equals方法

分析: 1:Person类 1:姓名和年龄 2:重写hashCode和equals方法 1:如果不重写,调用Object类的equals方法,判断内存地址,为false 1:如果是Person类对象,并且姓名和年龄相同就返回true 2:如果不重写,调用父类hashCode方法 1:如果equals方法相同,那么hashCode也要相同,需要重写hashCode方法 3:重写toString方法 1:不重写,直接调用Object类的toString方法,打印该对象的内存地址 Person类 cl

Java 中正确使用 hashCode 和 equals 方法

在这篇文章中,我将告诉大家我对hashCode和equals方法的理解.我将讨论他们的默认实现,以及如何正确的重写他们.我也将使用Apache Commons提供的工具包做一个实现. 目录: hashCode()和equals()的用法 重写默认实现 使用Apache Commons Lang包重写hashCode()和equals() 需要注意记住的事情 当使用ORM的时候特别要注意的 hashCode()和equals()定义在Object类中,这个类是所有java类的基类,所以所有的jav

重写HashCode和equals规范

hashcode 和 equals 方法是用来鉴定2个对象是否相等. 一般来讲,equals这个方法是给用户调用的,如果你想判断2个对象是否相等,你可以重写equals方法,然后在代码中调用 ,就可以判断他们是否相等了.简单来讲,equals方法主要是用来判断从表面上看或者从内容上看,2个对象是不是相等. 举个例子,有个学生类,属性只有姓名和性别,那么我们可以认为只要姓名和性别相等,那么就说这2个对象是相等的. 如下: package utils; public class Student {