【计算机基础】HashCode And Equals

柔情只为你懂 2023-02-28 04:16 37阅读 0赞

目录：

1.  Object类下的equals和hashCode:
2.  == 和 equals
3.  hashCode码的特点
4.  为什么重写equals建议一定要重写hashCode?

# Object类下的equals和hashCode: #

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

# == 和 equals #

> 对于值对象，比较的是两个对象的值  
> 对于引用对象， 比较的是两个对象的地址

如上代码Object类下的equals 通过==对比是当前对象和传入对象是否是同一个对象，对比的是两个对象的地址  
也就是即使是对象里面的值都是一样的，也会被判，这两对象不相等。通过代码来理解一下这句话：

public class Cat {
        int color,weight,height;
    
        public Cat(int color,int weight,int height){
            this.color = color;
            this.weight = weight;
            this.height = height;
        }
    }

public static void main(String[] args) {
            Cat c1 = new Cat(1, 1, 1);
            Cat c2 = new Cat(1, 1, 1);
    		
            System.out.println("c1==c2的结果是："+(c1==c2));
            System.out.println("c1.equals(c2)的结果是："+c1.equals(c2));
    
            System.out.println("c1.hashCode="+c1.hashCode());
            System.out.println("c2.hashCode="+c2.hashCode());
    }

> c1==c2的结果是：false  
> c1.equals(c2)的结果是：false  
> c1.hashCode=356573597  
> c2.hashCode=1735600054

通过结果可以知道：即使是一样的属性的Cat对象，hashcode和equals都是不同的。  
引用equals调用的是object的equals方法，通过thisobject判断当前对象和传入的对象也就是c1和c2的引用是否是同一个，答案当然是不一样，所以equals的结果和的结果是一样的，都是false。

不同对象他们的hashCode是不一样的。  
但思考：不同对象的hashCode一定是不一样的？

# hashCode码的特点 #

上面提到，不同对象的hashCode一定是不一样的？—不是  
那么反过来呢？  
一样的hashCode,一定是同一个对象吗？----不是  
相同对象的hashCode一定是一样的吗？-----是  
TODO：深入原理不太明白，看源码注释可以看到：

/**
         * Returns a hash code value for the object. This method is
         * supported for the benefit of hash tables such as those provided by
         * {@link java.util.HashMap}.
         * <p>
         * The general contract of {@code hashCode} is:
         * <ul>
         * <li>Whenever it is invoked on the same object more than once during
         *     an execution of a Java application, the {@code hashCode} method
         *     must consistently return the same integer, provided no information
         *     used in {@code equals} comparisons on the object is modified.
         *     This integer need not remain consistent from one execution of an
         *     application to another execution of the same application.
         * <li>If two objects are equal according to the {@code equals(Object)}
         *     method, then calling the {@code hashCode} method on each of
         *     the two objects must produce the same integer result.
         * <li>It is <em>not</em> required that if two objects are unequal
         *     according to the {@link java.lang.Object#equals(java.lang.Object)}
         *     method, then calling the {@code hashCode} method on each of the
         *     two objects must produce distinct integer results.  However, the
         *     programmer should be aware that producing distinct integer results
         *     for unequal objects may improve the performance of hash tables.
         * </ul>
         * <p>
         * As much as is reasonably practical, the hashCode method defined by
         * class {@code Object} does return distinct integers for distinct
         * objects. (This is typically implemented by converting the internal
         * address of the object into an integer, but this implementation
         * technique is not required by the
         * Java™ programming language.)
         *
         * @return  a hash code value for this object.
         * @see     java.lang.Object#equals(java.lang.Object)
         * @see     java.lang.System#identityHashCode
         */
        public native int hashCode();

>  *  If two objects are equal according to the \{@code equals(Object)\}

*     method, then calling the {@code hashCode} method on each of
     *     the two objects must produce the same integer result.
     *   如果根据{@code equals（Object）}两个对象相等方法，然后对每个

这两个对象必须产生相同的整数结果

# 为什么重写equals建议一定要重写hashCode? #

hashCode的计算基础是根据equals来计算的。如上，相同对象的hashcode一定是一样的。  
在使用hashCode和equals的时候，是通过先对比hashCode,看hashCode如果相同，再对比equals,如果equals的结果是true，则表示两个对象一样的。如果hashCode不同，那么就认定这两个对象不同了。

所以，如果你更换的equals的对比规则，但是没有更新hashCode的计算规则，即使equals是true,但是hashCode还是按照this==object的规则进行对比的，那么存储的时候hashCode的值也是按照不同对象去存储的，所以会出现本来是相同对象，却按照两个不同对象取出的情况。

举个例子：  
HashSet,set集合的特定就是存储的对象是惟一的

public static void main(String[] args) {
            HashSet<RectObject> set = new HashSet<RectObject>();
            RectObject r1 = new RectObject(3,3);
            RectObject r2 = new RectObject(5,5);
            RectObject r3 = new RectObject(3,3);
            System.out.println("r1.equals(r3)的结果："+r1.equals(r3));
            System.out.println("r1.hashCode()"+r1.hashCode());
            System.out.println("r3.hashCode()"+r3.hashCode());
            
            set.add(r1);
            set.add(r2);
            set.add(r3);
            System.out.println("Set集合的size:"+set.size());
        }

r1.equals(r3)的结果：true  
r1.hashCode()356573597  
r3.hashCode()1735600054  
Set集合的size:3

从结果可以看到，虽然r1和r3的结果是true, 但是Set集合却当做两个不同的对象插入了。

原因在于：  
RectObject类中重写了equals方法，没有重写hashCode方法

public class RectObject {
        public int x;
        public int y;
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            RectObject that = (RectObject) o;
            return x == that.x &&
                    y == that.y;
        }
    
    //    @Override
    //    public int hashCode() {
    //        return Objects.hash(x, y);
    //    }
    }

> 重写了hashCode之后的运行结果：  
> r1.equals(r3)的结果：true  
> r1.hashCode()1057  
> r3.hashCode()1057  
> Set集合的size:2

发表评论取消回复

表情：

评论列表（有 0 条评论，37人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java基础（1）hashCode()和equals()

在Java中，hashCode()和equals()方法在处理对象相等性时扮演着关键角色，尤其是在使用集合类（如HashMapHashSet等）时。这两个方法位于类中，因...

短命女/ 2024年05月06日 23:22/ 0 赞/ 205 阅读

相关 JAVA基础——hashCode和equals的关系

equals equals()源自于java.lang.Object,该方法用来简单验证两个对象的相等性。Object类中定义的默认实现只检查两个对象的对象引用，以验证它

雨点打透心脏的1/2处/ 2023年09月23日 23:25/ 0 赞/ 175 阅读

相关 java基础：hashCode 与 equals

HashSet如何检查重复两个对象的 hashCode() 相同，则 equals() 也一定为 true，对吗？ hashCode和equals方法的关系面试官可能

青旅半醒/ 2023年07月10日 11:14/ 0 赞/ 94 阅读

相关基础面试题：hashCode 与 equals

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

桃扇骨/ 2023年05月22日 04:37/ 0 赞/ 84 阅读

相关【计算机基础】HashCode And Equals

目录： 1. Object类下的equals和hashCode: 2. == 和 equals 3. hashCode码的特点 4. 为什么重写equals建议一定要

柔情只为你懂/ 2023年02月28日 04:16/ 0 赞/ 38 阅读

相关 java基础之hashCode和equals分析

写在前面本文参考[这篇文章][Link 1]，写的非常详细。 1：Object类 hashCode和equals方法是在java的顶层类`java.lang.O

古城微笑少年丶/ 2023年01月13日 05:46/ 0 赞/ 316 阅读

相关 HashCode/Equals/==

概述首先 `equals` 和 `hashCode` 两个方法属于 Object 基类的方法： public boolean equals(Object ob

缺乏、安全感/ 2022年11月06日 02:51/ 0 赞/ 312 阅读

相关 equals和hashCode

1.重写equals方法的原因根据Object源码 public boolean equals(Object obj) { return (thi

水深无声/ 2022年04月08日 13:38/ 0 赞/ 472 阅读

相关 Java基础之equals和hashCode方法

HashSet和HashMap一直都是JDK中最常用的两个类，HashSet要求不能存储相同的对象，HashMap要求不能存储相同的键。那么Java虚拟机是如何判断HashS

ゝ一世哀愁。/ 2022年01月07日 22:11/ 0 赞/ 368 阅读

相关 equals和hashcode

本章的内容主要解决下面几个问题： 1 equals() 的作用是什么？ 2 equals() 与 == 的区别是什么？ 3 hashCode() 的作用是什么？ 4 h

柔光的暖阳◎/ 2021年11月23日 16:14/ 0 赞/ 624 阅读