Java之hashCode()和equals()方法

时间  2019-11-07
标签 java hashcode equals 方法 栏目 Java 繁體版
原文   原文链接

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

1 equals() 的做用是什么？数组

2 equals() 与 == 的区别是什么？数据结构

3 hashCode() 的做用是什么？函数

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

第1部分 equals() 的做用spa

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

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。get


下面，举例对上面的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个元素进行比较”？显然，这个效率是相等低下的。散列表很好的解决了这个问题，它根据元素的散列码计算出元素在散列表中的位置，而后将元素插入该位置便可。对于相同的元素，天然是只保存了一个。
        由此可知，若两个元素相等，它们的散列码必定相等；但反过来确不必定。在散列表中，
                           一、若是两个对象相等，那么它们的hashCode()值必定要相同；
                           二、若是两个对象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被视为不相等。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程