java中equals方法和hashcode方法的区别和联系，以及为什么要重写这两个方法，不重写会怎样...

最新推荐文章于 2023-07-26 12:04:54 发布

weixin_30521649

最新推荐文章于 2023-07-26 12:04:54 发布

阅读量164

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/erma0-007/p/8607634.html

版权

一、在Object类中的定义为:
public native int hashCode();
是一个本地方法，返回的对象的地址值。
但是，同样的思路，在String等封装类中对此方法进行了重写。方法调用得到一个计算公式得到的 int值。

二、在重写任何类得hashcode方法时必须遵循以下几点：
1、在Java应用的同一次执行过程中，同一对象被多次调用，则他们的hashcode值必然相同。
而对于同一个应用的两次不同的调用，它们的Hashcode值可以相同，也有可能不同。
2、对于两个对象来说，如果他们的equals方法比较返回true，那么这两个对象的hashcode必然相同。
这也解释了为什么String类中，如果两个对象的equals方法相同，则他们的hashcode值一定相同。

3、对于两个对象来说，如果使用equals方法返回为false，则他们的hashcode的值有可能相等也可能不等，
（如果不同会提高性能，因为在集合中类判断两个对象是否相等，如果其hashcode不等就直接不用判断equals方法了）
4、对于Object对象来说，不同的Object对象的hashcode是不同的，它们返回的是对象的地址，
equals返回的也是对象的地址。所以在自己定义的类中如果要添加到集合对象中，
最好是要重写hashcode和equals方法，不然会自动继承自Object类中的两个方法根据对象地址来判断。
在重写自己定义的类时，通常是在类中的根据某个值如name.hashcode();来进行判断。

三、以HashSet 为例：
当我们使用HashSet时，hashCode()方法就会被得到调用，判断已经存储在集合中的对象的hashCode值是否与所增加。
对象的hashCode值一致，如果“不一致”则直接加进去（不用比较equals()提高效率），如果一致，则进行equals方法的比较，如果返回true，表明集合里面已经有这个对象，不能添加进去了。如果是false表是集合里面没有这个对象，则可以加进去。所以在重写hashcode()或者equals() 方法的任何一个方法时，必须重写另外一个。 
示例代码：
/** 
* People 手工重写hashcode方法和equals方法 根据name来判断 两个对象是否相等。 
*/ 
class People { 
private String name; 
public People(String name) { 
this.name = name; 
} 
@Override 
public boolean equals(Object obj) { 
//如果是自己 
if(this==obj){ 
return true ; 
} 
//如果是空 
if(obj==null ){ 
return false; 
} 
//比较两个People的名字是否相同 
if(obj!=null && obj instanceof People){ 
if(((People)obj).name.equals(this.name)) 
return true ; 
} 
return false; 
} 
@Override 
public int hashCode() { 
// String的hashcode本来就是用来比较两个字符是否相等 
return name.hashCode(); 
} 
}

从Object类的hashCode()和equals()方法讲起：

最近看了Object类的源码，对hashCode() 和equals()方法有了更深的认识。重写equals()方法就必须重写hashCode()方法的原因，从源头Object类讲起就更好理解了。

先来看Object关于hashCode()和equals()的源码：

[java] view plain copy

public native int hashCode();

[java] view plain copy

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

     光从代码中我们可以知道，hashCode()方法是一个本地native方法，返回的是对象引用中存储的对象的内存地址，而equals方法是利用==来比较的也是对象的内存地址。从上边我们可以看出，hashCode方法和equals方法是一致的。还有最关键的一点，我们来看Object类中关于hashCode()方法的注释：

[java] view plain copy

/**
* 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}.
*
* 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 not 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>
*
* 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();

    简单的翻译一下就是，hashCode方法一般的规定是：

[java] view plain copy

1.在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。
2.如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
3.如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不要求一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

再简单的翻译一下第二三点就是：hashCode()和equals()保持一致，如果equals方法返回true，那么两个对象的hasCode()返回值必须一样。如果equals方法返回false，hashcode可以不一样，但是这样不利于哈希表的性能，一般我们也不要这样做。重写equals()方法就必须重写hashCode()方法的原因也就显而易见了。

假设两个对象，重写了其equals方法，其相等条件是属性相等，就返回true。如果不重写hashcode方法，其返回的依然是两个对象的内存地址值，必然不相等。这就出现了equals方法相等，但是hashcode不相等的情况。这不符合hashcode的规则。下边，会介绍在集合框架中，这种情况会导致的严重问题。

重写的作用：

如果重写（用于需求，比如建立一个Person类，比较相等我只比较其属性身份证相等就可不管其他属性，这时候重写）equals，就得重写hashCode，和其对象相等保持一致。如果不重写，那么调用的Object中的方法一定保持一致。

1. 重写equals()方法就必须重写hashCode()方法主要是针对HashSet和Map集合类型。集合框架只能存入对象（对象的引用（基本类型数据：自动装箱））。

在向HashSet集合中存入一个元素时，HashSet会调用该对象（存入对象）的hashCode()方法来得到该对象的hashCode()值，然后根据该hashCode值决定该对象在HashSet中存储的位置。简单的说：HashSet集合判断两个元素相等的标准是：两个对象通过equals()方法比较相等，并且两个对象的HashCode()方法返回值也相等。如果两个元素通过equals()方法比较返回true，但是它们的hashCode()方法返回值不同，HashSet会把它们存储在不同的位置，依然可以添加成功。同样：在Map集合中，例如其子类Hashtable（jdk1.0错误的命名规范），HashMap，存储的数据是<key,value>对，key，value都是对象，被封装在Map.Entry，即：每个集合元素都是Map.Entry对象。在Map集合中，判断key相等标准也是：两个key通过equals()方法比较返回true，两个key的hashCode的值也必须相等。判断valude是否相等equal()相等即可。

稍微提一句：（1）两个对象，用==比较比较的是地址，需采用equals方法（可根据需求重写）比较。

（2）重写equals()方法就重写hashCode()方法。

（3）一般相等的对象都规定有相同的hashCode。

hash：散列，Map关联数组，字典

2. 集合类都重写了toString方法。String类重写了equal和hashCode方法，比较的是值。

用HashSet来验证两个需都重写的必要性

程序提供了三个类A,B,C，它们分别重写了equals()，hashCode()两个方法中的一个或全部。

class A {
String certificate;

public A(String certificate) {

this.certificate = certificate;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
A other = (A) obj;
if (certificate == null) {
if (other.certificate != null)
return false;
} else if (!certificate.equals(other.certificate))
return false;
return true;
}

}

class B {
String certificate;// 身份证号

public B(String certificate) {

this.certificate = certificate;
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((certificate == null) ? 0 : certificate.hashCode());
return result;
}
}

class C {
String certificate;

public C(String certificate) {

this.certificate = certificate;
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((certificate == null) ? 0 : certificate.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
C other = (C) obj;
if (certificate == null) {
if (other.certificate != null)
return false;
} else if (!certificate.equals(other.certificate))
return false;
return true;
}

}

package day02;

import java.util.HashSet;

public class EqualsHashcodeDemo {
public static void main(String[] args) {

HashSet<A> hashSetA = new HashSet();
hashSetA.add(new A("123"));
hashSetA.add(new A("123"));
for (Object hs : hashSetA) {
System.out.println(hs);
}

HashSet hashSetB = new HashSet();
hashSetB.add(new B("345"));
hashSetB.add(new B("345"));
for (Object hs : hashSetB) {
System.out.println(hs);
}
HashSet<C> hashSetC = new HashSet<C>();
hashSetC.add(new C("456"));
hashSetC.add(new C("456"));
for (Object hs : hashSetC) {
System.out.println(hs);
}
/**
* public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { char
* val[] = value;
*
* for (int i = 0; i < value.length; i++) { h = 31 * h + val[i]; } hash = h; }
* return h; }
*/