文档章节

Java之hashCode()和equals()方法

董广明
 董广明
发布于 2014/04/01 17:14
字数 3019
阅读 578
收藏 30

程序世界和现实世界其实是一样的,相等相同是不同的概念,就此简要说明一下其中的含义:

1 equals() 的作用是什么?

2 equals() 与 == 的区别是什么?

3 hashCode() 的作用是什么?

4 hashCode() 和 equals() 之间有什么联系?

第1部分 equals() 的作用

equals() 的作用是 用来判断两个对象是否相等。有5个很重要的特性:

1. 对称性:如果x.equals(y)返回是"true",那么y.equals(x)也应该返回是"true"。
2. 反射性:x.equals(x)必须返回是"true"。
3. 类推性:如果x.equals(y)返回是"true",而且y.equals(z)返回是"true",那么z.equals(x)也应该返回是"true"。
4. 一致性:如果x.equals(y)返回是"true",只要x和y内容一直不变,不管你重复x.equals(y)多少次,返回都是"true"。
5. 非空性,x.equals(null),永远返回是"false";x.equals(和x不同类型的对象)永远返回是"false"。


equals() 定义在JDK的Object.java中。通过判断两个对象的地址是否相等(即,是否是同一个对象)来区分它们是否相等。源码如下:

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

既然Object.java中定义了equals()方法,这就意味着所有的Java类都实现了equals()方法,所有的类都可以通过equals()去比较两个对象是否相等。 但是,我们已经说过,使用默认的“equals()”方法,等价于“==”方法。因此,我们通常会重写equals()方法:若两个对象的内容相等,则equals()方法返回true;否则,返回fasle。  

下面根据“类是否覆盖equals()方法”,将它分为2类。
(01) 若某个类没有覆盖equals()方法,当它的通过equals()比较两个对象时,实际上是比较两个对象是不是同一个对象。这时,等价于通过“==”去比较这两个对象
(02) 我们可以覆盖类的equals()方法,来让equals()通过其它方式比较两个对象是否相等。通常的做法是:若两个对象的内容相等,则equals()方法返回true;否则,返回fasle


下面,举例对上面的2种情况进行说明。

1.  “没有覆盖equals()方法”的情况,简要代码:

    public static void main(String[] args) {        
        Person p1 = new Person("dongguangming", 25);
        Person p2 = new Person("dongguangming", 25);
        System.out.println(p1.equals(p2));
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是:"+name + ",年龄是:" +age;
        }
    }

输出结果:false

结果分析: 我们通过 p1.equals(p2) 来“比较p1和p2是否相等时”。实际上,调用的Object.java的equals()方法,即调用的 (p1==p2) 。它是比较“p1和p2是否是同一个对象”。
       而由 p1 和 p2 的定义可知,它们虽然内容相同;但它们是两个不同的对象!因此,返回结果是false。


2. "覆盖equals()方法"的情况,简要代码:

    public static void main(String[] args) {
     Person p1 = new Person("dongguangming", 25);
     Person p2 = new Person("dongguangming", 25);
     System.out.println(p1.equals(p2));
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是:"+name + ",年龄是:" +age;
        }
        
        //复写Object类中默认的equals()
        public boolean equals(Object obj){
        if(obj == null){
        return false;
        }
        
        //如果是同一个对象,返回ture
        if(this ==obj){
        return true;
        }
        
        //判断是否为同一类型
        if (this.getClass()!=obj.getClass())
        {
        return false;
        }
        
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }

输出结果:true

分析结论:由于重写了Person的equals()方法:当两个Person对象的 name 和 age 都相等,则返回true。因此,运行结果返回true。


第2部分 equals() 与 == 的区别是什么?

== : 它的作用是判断两个对象的地址是不是相等。即,判断两个对象是不试同一个对象。

equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况:
                 情况1,类没有盖equals()方法。则通过equals()比较该类的两个对象时,等价于通过“==”比较这两个对象。
                 情况2,类覆盖了equals()方法。一般,我们都覆盖equals()方法来两个对象的内容相等;若它们的内容相等,则返回true(即,认为这两个对象相等)。

简要代码如下:

   public static void main(String[] args) {
     Person p1 = new Person("dongguangming", 25);
     Person p2 = new Person("dongguangming", 25);
     System.out.println(p1.equals(p2));
     System.out.println(p1.==p2);
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是:"+name + ",年龄是:" +age;
        }
        
        //复写Object类中默认的equals()
        public boolean equals(Object obj){
        if(obj == null){
        return false;
        }
        
        //如果是同一个对象,返回ture
        if(this ==obj){
        return true;
        }
        
        //判断是否为同一类型
        if (this.getClass()!=obj.getClass())
        {
        return false;
        }
        
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }

输出结果:true,false

结论分析:

a. p1.equals(p2) 
        这是判断p1和p2的内容是否相等。因为Person覆盖equals()方法,而这个equals()是用来判断p1和p2的内容是否相等,恰恰p1和p2的内容又相等;因此,返回true。

b. p1==p2
       这是判断p1和p2是否是同一个对象。由于它们是各自新建的两个Person对象;因此,返回false。

 

第3部分 hashCode() 的作用

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

hashCode() 定义在JDK的Object.java中,这就意味着Java中的任何类都包含有hashCode() 函数。
        虽然,每个Java类都包含hashCode() 函数。但是,仅仅当创建并某个“类的散列表”(关于“散列表”见下面说明)时,该类的hashCode() 才有用(作用是:确定该类的每一个对象在散列表中的位置;其它情况下(例如,创建类的单个对象,或者创建类的对象数组等等),类的hashCode() 没有作用。
       上面的散列表,指的是:Java集合中本质是散列表的类,如HashMap,Hashtable,HashSet。

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

下面,我们以HashSet为例,来深入说明hashCode()的作用。

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

                           注意:这是在散列表中的情况。在非散列表中一定如此!


第4部分 hashCode() 和 equals() 的关系

我们以“类的用途”来将“hashCode() 和 equals()的关系”分2种情况来说明。

1. 第一种 不会创建“类对应的散列表”

         这里所说的“不会创建类对应的散列表”是说:我们不会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据结构中,用到该类。例如,不会创建该类的HashSet集合。

        在这种情况下,该类的“hashCode() 和 equals() ”没有关系!
        这种情况下,equals() 用来比较该类的两个对象是否相等。而hashCode() 则根本没有任何作用,所以,不用理会hashCode()。

下面,我们通过示例查看类的两个对象相等 以及 不等时hashCode()的取值。

public static void main(String[] args) {
     Person dongguangming = new Person("dongguangming", 25);
     Person dgm= new Person("dongguangming", 25);
     Person gaoyafei = new Person("gaoyafei", 25);
     System.out.println(dongguangming.equals(dgm)+","+dongguangming.hashCode()+","+dgm.hashCode());
    System.out.println(dongguangming.equals(gaoyafei)+","+dongguangming.hashCode()+","+gaoyafei.hashCode());
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是:"+name + ",年龄是:" +age;
        }
        
        //复写Object类中默认的equals()
        public boolean equals(Object obj){
        if(obj == null){
        return false;
        }
        
        //如果是同一个对象,返回ture
        if(this ==obj){
        return true;
        }
        
        //判断是否为同一类型
        if (this.getClass()!=obj.getClass())
        {
        return false;
        }
        
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }

输出结果:

true,6413875,21174459

false,6413875,827574

由此得出结论:对象相等的情况下,hashCode不一定相等。

2. 第二种 会创建“类对应的散列表”

        这里所说的“会创建类对应的散列表”是说:我们会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据结构中,用到该类。例如,会创建该类的HashSet集合。

        在这种情况下,该类的“hashCode() 和 equals() ”是有关系的
        1)、如果两个对象相等,那么它们的hashCode()值一定相同。
              这里的相等是指,通过equals()比较两个对象时返回true。
        2)、如果两个对象hashCode()相等,它们并不一定相等。

               因为在散列表中,hashCode()相等,即两个键值对的哈希值相等。然而哈希值相等,并不一定能得出键值对相等。补充说一句:“两个不同的键值对,哈希值相等”,这就是哈希冲突。

        此外,在这种情况下。若要判断两个对象是否相等,除了要覆盖equals()之外,也要覆盖hashCode()函数。否则,equals()无效。
例如,创建Person类的HashSet集合,必须同时覆盖Person类的equals() 和 hashCode()方法。
        如果单单只是覆盖equals()方法。我们会发现,equals()方法没有达到我们想要的效果。

简要代码如下:

public static void main(String[] args) {
     Person dongguangming = new Person("dongguangming", 25);
     Person dgm= new Person("dongguangming", 25);
     Person gaoyafei = new Person("gaoyafei", 25);
     System.out.println(dongguangming.equals(dgm)+","+dongguangming.hashCode()+","+dgm.hashCode());
     HashSet<Person> ps = new HashSet<Person>();
     ps.add(dongguangming);
     ps.add(dongguangmingdgm);
     ps.add(gaoyafei);
     System.out.println(ps);
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是:"+name + ",年龄是:" +age;
        }
        
        //复写Object类中默认的equals()
        public boolean equals(Object obj){
        if(obj == null){
        return false;
        }
        
        //如果是同一个对象,返回ture
        if(this ==obj){
        return true;
        }
        
        //判断是否为同一类型
        if (this.getClass()!=obj.getClass())
        {
        return false;
        }
        
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }

输出结果:

true,6413875,21174459

[名字是:dongguangming,年龄是:25, 名字是:gaoyafei,年龄是:25, 名字是:dongguangming,年龄是:25]

(注:有重复元素dongguangming,年龄是:25两次)

分析

 我们重写了Person的equals()。但是,很奇怪的发现:HashSet中仍然有重复元素:dongguangming和 dgm。为什么会出现这种情况呢?

        这是因为虽然dongguangming 和 dgm的内容相等,但是它们的hashCode()不等;所以,HashSet在添加dongguangming和dgm的时候,认为它们不相等。


下面,我们同时覆盖equals() 和 hashCode()方法。简要代码如下:

public static void main(String[] args) {
     Person dongguangming = new Person("dongguangming", 25);
     Person dgm= new Person("dongguangming", 25);
     Person gaoyafei = new Person("gaoyafei", 25);
     Person dgm_DGM = new Person("DONGGUANGMING", 25);
     System.out.println(dongguangming.equals(dgm)+","+dongguangming.hashCode()+","+dgm.hashCode());
     System.out.println(dongguangming.equals(dgm_DGM)+","+dongguangming.hashCode()+","+dgm_DGM.hashCode());
     HashSet<Person> ps = new HashSet<Person>();
     ps.add(dongguangming);
     ps.add(dongguangmingdgm);
     ps.add(gaoyafei);
     ps.add(dgm_DGM);
     System.out.println(ps);
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是:"+name + ",年龄是:" +age;
        }
        
        //复写Object类中默认的hashCode()方法
	public int hashCode(){
	    return name.toUpperCase().hashCode()*age;
	}
		
        //复写Object类中默认的equals()
        public boolean equals(Object obj){
        if(obj == null){
        return false;
        }
        
        //如果是同一个对象,返回ture
        if(this ==obj){
        return true;
        }
        
        //判断是否为同一类型
        if (this.getClass()!=obj.getClass())
        {
        return false;
        }
        
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }

输出结果:

true,-1515325931,-1515325931

false,-1515325931,-1515325931

[名字是:DONGGUANGMING,年龄是:25, 名字是:dongguangming,年龄是:25, 名字是:gaoyafei,年龄是:25]

(注:无重复元素dongguangming,年龄是:25一次)

结果分析

        这下,equals()生效了,HashSet中没有重复元素。
        比较dongguangming和dgm,我们发现:它们的hashCode()相等,通过equals()比较它们也返回true。所以,dongguangming和dgm被视为相等。
        比较dongguangming和dgm_DGM,我们发现:虽然它们的hashCode()相等;但是,通过equals()比较它们返回false。所以,dongguangming和dgm_DGM被视为不相等。









© 著作权归作者所有

董广明
粉丝 21
博文 43
码字总数 36868
作品 0
南京
前端工程师
私信 提问
加载中

评论(3)

董广明
董广明 博主

引用来自“郏高阳”的评论

引用来自“杨旭”的评论

HashSet不允许有重复的元素

嗯,楼主少一个字

可能内容写的太多了,没一个字一个字的审核,你看的好仔细

郏高阳
郏高阳

引用来自“杨旭”的评论

HashSet不允许有重复的元素

嗯,楼主少一个字
杨旭
HashSet不允许有重复的元素
用来理解 Java 编程语言的 8 个图表

很多时候,一张图比你说 1000 个字能更有效的说清楚一个问题。我们列举了 8 个关于 Java 语言的图表,或许可以让你对 Java 有着更深入的认识。 1. 字符串不变性(String Immutability) 下面的...

oschina
2013/09/23
7.8K
29
GC复制存活的对象,内存地址会变吗?以前的引用怎么办?

问题 先执行gc方法,10S后打印数组的地址,发现没变,是不是说明复制算法不改变对象的内存地址 解读 toString打印的值现有的匿名回答是正解:题主做的实验根本没有涉及对象地址。java.lang.O...

细节探索者
02/13
0
0
Java拾遗:001 - 重写 equals 和 hashCode 方法

重写equals方法 在Java中Object类是一个具体类,但它设计的主要目的是为了扩展,所以它的所有非final方法,都被设计成可覆盖(override)的。但任何一个子类在覆盖这些方法时都应遵守一些通用...

一别丶经年
2018/08/02
0
0
最最最常见的Java面试题总结-第一周

这里会分享一些出现频率极其极其高的面试题,初定周更一篇,什么时候更完什么时候停止。 Github地址:https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/最最最常见的Java面试...

Amsour丶
2018/08/08
0
0
scala中的==、equals、eq

scala中equals方法和==是检查值是否相等,而eq方法检查的是引用是否相等。 Scala 的==与Java的有何差别 Java 里的既可以比较基本类型也可以比较引用类型。对于基本类型,Java 的==比较 值比较...

张欢19933
2018/04/27
0
0

没有更多内容

加载失败,请刷新页面

加载更多

数据科学热潮下的冷思考:什么才是最需要的技能?

全文共3087字,预计学习时长6分钟 图片来源:pexels.com/@freestocks 数据科学已经进入了稳定生产的成熟期,数据科学家所需的技能也在与时俱进。不仅是追求更高效的机器学习模型,在当下,推...

读芯术
16分钟前
0
0
48.Nginx访问日志 日志切割 静态文件不记录

12.10 Nginx访问日志 12.11 Nginx日志切割 12.12 静态文件不记录日志和过期时间 12.10 Nginx访问日志: ~1.日志格式 vim /usr/local/nginx/conf/nginx.conf //搜索log_format log_format com...

oschina130111
21分钟前
1
0
好程序员分享Css详解bem书写规范

  好程序员分享Css详解bem书写规范,bem是基于组件的web开发方法。其思想是将用户界面分隔为独立的块,从而使开发复杂的UI界面变得更简单和快,且不需要粘贴复制便可复用现有代码。BEM由B...

好程序员IT
25分钟前
0
0
基于cm+cdh搭建大数据集群

第一部分:搭建基本环境 1、网络配置 vim /etc/sysconfig/network-scripts/ifcfg-ens32 service network restart vim /etc/hosts 192.168.15.121 node1 192.168.15.122 node2 192.168.15.123......

一个点一个点
34分钟前
0
0
[学]ngin反向代理搭建与配置

Nginx安装地址:https://www.cnblogs.com/wyd168/p/6636529.html (linux) 必须安装的4个包: nginx-1.1.10.tar.gz openssl-1.0.1t.tar.gz pcre-8.39.tar.gz zlib-1.2.11.tar.gz ng配置主要......

覃光林
40分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部