(强制)要求覆写equals必须覆写hashCode(原理分析)

简介: hashCode和equalshashCode和equals用来标识对象,两个方法协同工作可用来判断两个对象是否相等。众所周知,根据生成的哈希将数据散列开来,可以使存取元素更快。对象通过调用Object.hashCode()生成哈希值;由于不可避免会存在哈希值冲突 的情况,因此当hashCode相同时,还需要再调用equals进行一次值的比较;但是若hashCode不同,将直接判定Object不同,跳过equals,这加快了冲突处理效率。Object类定义中对hashCode和equals要求如下:

hashCode和equals

hashCode和equals用来标识对象,两个方法协同工作可用来判断两个对象是否相等。众所周知,根据生成的哈希将数据散列开来,可以使存取元素更快。对象通过调用Object.hashCode()生成哈希值 ;由于不可避免会存在哈希值冲突 的情况 ,因此当hashCode相同时,还需要再调用equals进行一次值的比较;但是若hashCode不同,将直接判定Object不同,跳过equals,这加快了冲突处理效率 。Object类定义中对hashCode和equals要求如下:

(1)如果两个对象的equals的结果是相等的,则两个对象的hashCode的返回值结果也必要是相同的。

(2)任何时候覆写equals,都必须同时覆写hashCode。

在Map和Set集合中,用到这两个方法时,首先判断hashCode的值,如果hash相等,则再判断equals的结果,HashMap的get判断代码如下

if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))){
    return (e = getNode(hash(key), key)) ==null ? null :e.value;
}

if条件表达式中的e.hash == hash是先决条件,只有相等才会执行&&后的部分。如果不相等,则&&后面的equals根本不会被执行。equals不相等时并不强制要求hashCode也不相等,但一个优秀的哈希算法应尽可能地让元素均匀分布,降低冲突概率,即在equals不相等时hashCode也不相等,这样&&或||短路 操作一旦生效,会极大提高程序的执行效率。如果自定义对象作为Map的键 ,那么必须覆写hashCode和equals。此外,因为Set存储的是不可重复的对象。依据hashCode和equals进行判断,所以Set存储的自定义对象也必须覆写这两个方法。此时如果覆写了equals,而没有覆写hashCode,具体会有什么影响,让我们通过以下代码深入体会:

public class EqualsObject{
    privite int id;
    privite String name;
    
    public EqualsObject(int id, String name){
        this.id = id;
        this.name = name;
    }
    
    @Override
    public boolean equals(Object obj){
        // 如果为null,或者并非同类,则直接返回false(第一处)
        if (obj == null || this.getClass() != obj.class()){
            return false;
        }
        
        // 如果引用指向同一个对象,则返回true
        if(this == obj){
            return true;
        }
        
        // 需要强制类型转换来获取EqualsObject的方法
        EqualsObject temp = (EqualsObject)obj;
        // 本示例判断标准是两个属性值相等,逻辑随业务场景不同而不同
        if (temp.getId() == this.id && name.equals(temp.getName())){
            return true;
        }
        return false;
    }
}

第一处说明:首先判断两个对象的类型是否相同,如果不匹配则直接返回false 。此处使用getClass的方式,就是严格限制了只有EqualsObject对象本身才可以执行equals操作。

这里并没有覆写hashCode,那么把这个对象放到Set集合中去:

Set<EqualsObject> hashSet = new HashSet<>();
EqualsObject a = new EqualsObject(1,"one");
EqualsObject b = new EqualsObject(1,"one");
EqualsObject c = new EqualsObject(1,"one");

hashSet.add(a);
hashSet.add(b);
hashSet.add(c);
System.out.println(hashSet.size());

输出结果是3,。虽然这些对象显而易见是相同的 ,但在HashSet操作中,应该只剩下一个,为什么结果是3呢?因为如果不覆写hashCode(),即使equals()相等也毫无意义,Object.hashCode()的实现是默认为每一个对象生成不同的int值,它本身是Native 方法,一般与对象内存地址有关。下面查看C++的源码实现:

VM_ENTRY(jint, JVM_IHashCode(JNIEnv* env,jobject handle))
    JVMWrapper("JVM_IHashCode");
    return handle == NULL ? 0 : objectSynchronizer::FashHashCode
        (THREAN,JNIHandles::resolve_non_null(handle));
VM_END

ObjectSynchronizer的核心代码如下,从代码分析角度也印证了hashCode就是根据对象的地址进行相关计算得到int类型数值的:

mark = monitor->header();
assert(mark->is_neutral(),"invariant");
hash = mark->hash();

intptr_t hash() const{
    return mask_bits(value() >> hash_shift, hash_mask);
}

因为EqualsObject没有覆写hashCode,所以得到的是一个与对象地址相关的唯一值,回到刚才的HashSet集合上 ,如果想存储不重复的元素,那么需要在EqualsObject类中覆写hashCode();

@Override
public int hashCode(){
    return id + name.hashCode();
}

EqualsObject的name属性是String类型,String覆写了hashCode(),所以可以直接调用。equals()的实现方式与类的具体逻辑 有关,但又各部相同,因而应尽量分析源码来确定其判断结果,比如下列代码:

public class ListEquals(){
    public static void main(String[] args){
        LinkedList<Integer> linkedList = new LinkedList<Integer>();
        linkedList.add(1);
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(1);
        
        if (arrayList.equals(linkedList)){
            System.out.println("equals is true");
        } else {
            System.out.println("equals is false");
        }
    }
}

两个不同的集合类,输出的结果是equals is true。因为ArrayList的equals()只进行了是否为List子类的判断 ,接着调用了equalsRange()方法:

boolean equalsRange(List<?> other,int form,int to){
    final Object[] es = elementData;
    //用var变量接受linkedList的遍历器(第一处)
    var oit = other.iterator();
    for(; form < to; form++){
        //如果linkedList没有元素,则equals结果直接为false;
        //如果linkList有元素,则再对应的下标进行值的比较(第二处)
        if (!oit.hasNext() || !Objects.equals(es[form], oit.next())){
            return false;
        }
    }
    // 如果ArrayList已经遍历完,而linkList还有元素,则equals结果为false
    return !oit.hasNext;
}

第一处说明:局部变量类型推断(Local Variable Type Inference)是JDK10引入的变量命名机制 ,一改Java是强类型语言的传统形象,这是Java致力于未来体积跟小、面向生产效率的新语言特性,减少累赘的语法规则,当然这仅仅是一个语法糖 ,Java仍然是一种静态语言。在初始化阶段,在处理var变量的时候,编译器会检测右侧代码的返回类型,并将其类型用于左侧,如下所示:

var a = "String";
// 输出:class java.lang.String
System.out.println(a.getClass());
var b = Integer.valueOf(7);
// 输出:class java.lang.Integer
System.out.println(b.getClass());
// 编译出错。虽然是var,但是依然存在类型限定
b = 3.0;

b在第一次赋值时,类型推断为Integer,所以在第二次赋值为double时编译出错。如果一个方法内频繁地使用var,则会大大降低可读性,这是一个权衡,建议当用var定义变量时,尽量不要超过两个

第二处说明:尽量避免通过实例对象引用来调用equals方法,否则容易抛出空指针异常。推荐使用JDK7引入的Objects的equals 方法,源码如下,可以有效地防止equals调用时产生NPE问题:

public static boolean equals(Object a,Object b){
    return (a==b) || (a != null && a.equals(b));
}
目录
相关文章
|
7月前
|
存储 算法 Java
为什么要重写 hashcode 和 equals 方法
为什么要重写 hashcode 和 equals 方法
59 0
|
2月前
|
存储 算法 Java
为什么重写 equals 方法时必须同时重写 hashCode 方法?
本文探讨了 Java 中 `hashCode` 方法的作用及其与 `equals` 方法的关系,解释了为什么重写 `equals` 方法时必须同时重写 `hashCode` 方法,并提供了如何正确重写 `hashCode` 方法的示例。
|
存储
重写equals后为什么要重写hashcode方法
重写equals后为什么要重写hashcode方法
69 0
|
7月前
|
存储 Java
为什么要重写hashCode()和equals()(深入了解)
为什么要重写hashCode()和equals()(深入了解)
|
7月前
|
存储 IDE Java
为什么重写 equals() 时必须重写 hashCode() 方法?(简单易理解)
为什么重写 equals() 时必须重写 hashCode() 方法?(简单易理解)
50 1
|
存储
为什么重写 equals 方法就必须重写 hashCode 方法?
为什么重写 equals 方法就必须重写 hashCode 方法?
80 0
为什么要重写 hashcode 和 equals 方法?
为什么要重写 hashcode 和 equals 方法?
85 0
|
存储 Java 对象存储
JavaSE——为什么重写equals的同时一定要重写hashCode?
JavaSE——为什么重写equals的同时一定要重写hashCode?
JavaSE——为什么重写equals的同时一定要重写hashCode?
|
Oracle Java 关系型数据库
为什么重写 equals() 方法,一定要重写 hashCode() 呢?| HashMap
首先我们有一个假设:任何两个 object 的 hashCode 都是不同的。 那么在这个条件下,有两个 object 是相等的,那如果不重写 hashCode(),算出来的哈希值都不一样,就会去到不同的 buckets 了,就迷失在茫茫人海中了,再也无法相认,就和 equals() 条件矛盾了,证毕。
152 0
为什么重写 equals() 方法,一定要重写 hashCode() 呢?| HashMap
|
存储 算法 Java
面试题系列第4篇:重写了equals方法,为什么还要重写hashCode方法?
面试题系列第4篇:重写了equals方法,为什么还要重写hashCode方法?
160 0
面试题系列第4篇:重写了equals方法,为什么还要重写hashCode方法?