首先,我们要知道equals()方法和hashcode()方法都属于Object类,这就意味着 Java 中的任何类都可调用Object类的方法;
下面我们看下源码:
equals()方法:
可以看出,在Object的源码,底层是用的"=="来比较的,也就是判断俩个的地址是不是一样的,这让这个equals方法在我们实际开发过程中没有了太大的实用价值,我们不是要地址的相等性,我们一般需要是逻辑上的相等,比如两个对象属性完全一样,我们就可以认为他一样(可参考下面的例子)。这时候我们就得重写equals方法了。
hashCode()方法:
hashCode() 的作用是获取哈希码,也称为散列码;实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。源码可以看出,hashCode()是一个native方法,哈希值的计算利用的是内存地址。
我们来看下Object类中关于hashCode()方法的注释,原文:
/**
* 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();
翻译一下,差不多这么个意思:
1.在执行过程中对同一对象多次调用hashCode方法时,必须始终返回相同的整数,但前提是equals方法比较时使用的对象没有被修改。同一个应用程序的一个执行与另一个执行,这个整数不需要保持一致。
2.如果equals(Object)}两个对象相等,那么两个对象必须产生相同的整数结果。即equals为true,则hashcode相等。
3.如果根据 equals(Object) 方法,两个对象不相等,不要求hashCode 方法一定生成不同的整数结果,但是,程序员应该意识到,为不相等的对象生成不同整数结果可以提高哈希表的性能。
总结一下:
A:如果两个对象相等,则 hashcode 一定也是相同的
B:两个对象有相同的 hashcode 值,它们也不一定是相等的
C:hashCode是为了提高性能
对于C,举个例子,HashSet 如何检查重复:
当你把对象加入 HashSet 时,HashSet 会先计算对象的 hashcode 值来判断对象加入的位置,同时也会与其他已经加入的对象的 hashcode 值作比较,如果没有相符的 hashcode,HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象,这时会调用 equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同,HashSet 就不会让其加入操作成功。
如果不同的话,就会重新散列到其他位置。这样我们就大大减少了 equals 的次数,相应就大大提高了执行速度。
好了,只是用文字来表示太空洞,我们上代码----》
新建一个测试user类(此时未重写equals和hashCode):
public class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
}
然后写个测试类
public class TestMain {
public static void main(String[] args) throws ParseException {
User u1=new User("张飒",123);
User u2=new User("张飒",123);
System.out.println(u1.equals(u2));
System.out.println("u1.hashCode():"+u1.hashCode());
System.out.println("u2.hashCode():"+u2.hashCode());
//Pair和Triple的使用,返回两个三个值的时候可用
Pair pair=new ImmutablePair(123,"qwer");
Triple triple=new ImmutableTriple(1,2,3);
System.out.println(pair);
System.out.println(triple);
}
运行测试类,可以看出是两个对象是不同,返回false
此时我们添加重写user的equals方法:
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age &&
Objects.equals(name, user.name);
}
运行我们的测试类,
可得到结果为true,hashcode不一样;
现在,将equals注释掉,重写hashCode方法:
运行测试了我们可以看出,hashcode一样,结果为false
最后,我们同时重写equals和hashCode方法,可以看到返回值是true,hashcode值也是相等的。
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age &&
Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
最后总结下为什么重写了equals要重写hashCode:
- 使用hashcode方法进行提前校验,可以避免每一次比对都调用equals方法,提高性能;
- 保证同一个对象。如果重写了equals方法,而没有重写hashcode方法,会出现equals相等的对象,hashcode不相等的情况,重写hashcode方法就是为了避免这种情况的出现。
关注公众号,回复 面试 获取初级中级高级面试题。