Java中重写equals()和hashCode()方法

原创

攻城狮Chova 2022-03-09 15:50:08 ©著作权

文章标签 java hashcode equals 重写 HashMap 文章分类 代码人生

©著作权归作者所有：来自51CTO博客作者攻城狮Chova的原创作品，请联系作者获取转载授权，否则将追究法律责任

重写equals和hashCode

基本概念
Object源码
重写equals
重写hashCode
原理分析
HashMap

HashMap组成结构
HashMap的存储

基本概念

要比较两个对象是否相等时需要调用对象的equals() 方法:

判断对象引用所指向的对象地址是否相等

对象地址相等时, 那么对象相关的数据也相等,包括:

对象句柄
对象头
对象实例数据
对象类型数据

可以通过比较对象的地址来判断对象是否相等

Object源码

对象在不重写的情况下使用的是Object中的equals() 方法和hashCode() 方法

equals(): 判断的是两个对象的引用是否指向同一个对象
hashCode(): 根据对象地址生成一个整数数值

Object的hashCode() 方法修饰符为native: 表明该方法是由操作系统实现. Java调用操作系统底层代码获取Hash值

public native int hashCode();

重写equals

重写equals()方法的场景:

假设现在有很多学生对象
默认情况下,要判断多个学生对象是否相等,需要根据地址判断:

若对象地址相等,那么对象实例的数据一定是一样的

判断相等的要求:

当学生的姓名,年龄,性别相等时,认为对象是相等的,
不一定需要对象的地址完全相同

根据需求重写equals()方法:

public class Student {
  /** 姓名 */
  private String name;
  /** 性别 */
  private String sex;
  /** 年龄 */
  private String age;
  /** 体重 */
  private float weight;
  /** 地址 */
  private String addr;

  /*
   * 重写equals()方法
   */
  @Override
  public boolean equals(Object obj) {
    // instanceof已经处理了obj == null的情况
      if (! (Object instanceof Student)) {

        return false;
      }
      Student stuObj = (Student) obj;
      // 地址相等
      if (this == stuObj) {
        return true;
      }
      // 如果对象的姓名,年龄,性别相等.则两个对象相等
      if (stuObj.name.equals(this.name) && stuObj.sex.equals(this.sex) && stuObj.age.equals(this.age)) {
        return true;
      } else {
        return false;
      }
   }

   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getSex() {
      return sex;
   }
   public void setSex(String sex) {
      this.sex = sex;
   }
    public String getAge() {
      return age;
   }
   public void setAge(String age) {
      this.age = age;
   }
   public String getWeight() {
      return weight;
   }
   public void setName(String weight) {
      this.weight = weight;
   }
   public String getAddr() {
      return addr;
   }
   public void setAddr(String addr) {
      this.addr = addr;
   }
}

示例:

public static void main(String[] args) {
  Student s1 = new Student();
  s1.setAddr("earth");
  s1.setAge("20");
  s1.setName("Tom");
  s1.setSex("Male");
  s1.setWeight(60f);

  Student s2 = new Student();
  s2.setAddr("Mars");
  s2.setAge("20");
  s2.setName("Tom");
  s2.setSex("Male");
  s2.setWeight(70f);

  if (s1.equals(s2)) {
    System.out.println("s1 == s2");
  } else {
    System.out.println("s1 != s2");
  }
}

重写了equals() 方法后,这里会输出 [s1==s2]
如果没有重写 equals() 方法,那么必定会输出 [s1!=s2]

重写hashCode

根据重写equals的方法,上述s1和s2认为是相等的
Object中的hashCode()方法:

在equals() 方法没被修改的前提下,多次调用同一个对象的hashCode() 方法返回的值必须是相同的正数
如果两个对象互相equals(), 那么这两个对象的hashcode值必须相等
为不同的对象生成不同的hashcode可以提升Hash表的性能

重写hashCode()方法:

```java
public class Student {
  /** 姓名 */
  private String name;
  /** 性别 */
  private String sex;
  /** 年龄 */
  private String age;
  /** 体重 */
  private float weight;
  /** 地址 */
  private String addr;

  /*
   * 重写hashCode()方法
   */
  @Override
  public int hashCode() {
    int result = name.hashCode();
    result = 17 * result + sex.hashCode();
    result = 17 * result + age.hashCode();
    return result;
   }

   /*
    * 重写equals()方法
    */
   @Override
   public boolean equals(Object obj) {
      // instanceof已经处理了obj == null的情况
      if (! (Object instanceof Student)) {

        return false;
      }
      Student stuObj = (Student) obj;
      // 地址相等
      if (this == stuObj) {
        return true;
      }
      // 如果对象的姓名,年龄,性别相等.则两个对象相等
      if (stuObj.name.equals(this.name) && stuObj.sex.equals(this.sex) && stuObj.age.equals(this.age)) {
        return true;
      } else {
        return false;
      }
   }

   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getSex() {
      return sex;
   }
   public void setSex(String sex) {
      this.sex = sex;
   }
   public String getAge() {
      return age;
   }
   public void setAge(String age) {
      this.age = age;
   }
   public String getWeight() {
      return weight;
   }
   public void setName(String weight) {
      this.weight = weight;
   }
   public String getAddr() {
      return addr;
   }
   public void setAddr(String addr) {
      this.addr = addr;
   }
}

在两个对象相等的情况下,分别放入Map和Set中:

public static void main(String[] args) {
  Student s1 = new Student();
  s1.setAddr("earth");
  s1.setAge("20");
  s1.setName("Tom");
  s1.setSex("Male");
  s1.setWeight(60f);

  Student s2 = new Student();
  s2.setAddr("Mars");
  s2.setAge("20");
  s2.setName("Tom");
  s2.setSex("Male");
  s2.setWeight(70f);

  if (s1.equals(s2)) {
    System.out.println("s1 == s2");
  } else {
    System.out.println("s1 != s2");
  }

  Set set = new HashSet();
  set.add(s1);
  set.add(s2);
  System.out.println(Set);
}

如果没有重写Object的hashCode() 方法,会出现:

[com.oxford.Student@7852e922, com.oxford.Student@4e25154f]

这是不符合预期的,因为Set容器有去重的特性.相等的元素不会重复显示.这就涉及到Set的底层实现了
HashSet底层实现:

HashSet底层是通过HashMap实现的
比较Set容器内元素是否相等是通过比较对象的hashcode来判断是否相等的

hashCode()的写法:

首先整理出判断对象相等的属性
然后去一个尽可能小的正整数,防止最终结果超出整型int的取数范围
然后计算[正整数 * 属性的hashCode + 其余某个属性的hashCode]
重复步骤

/*
 * 重写hashCode()方法
 */
@Override
public int hashCode() {
  int result = name.hashCode();
  result = 17 * result + sex.hashCode();
  result = 17 * result + age.hashCode();
  return result;
}

原理分析

因为没有重写父类的Object的hashCode() 方法,所以Object的hashCode() 方法会根据两个对象的地址生成响应的hashcode
由于两个对象分别是实体类创建的不同的实例,所以地址肯定是不一样的,那么hashcode值也是不一样的
Set区别对象是不是唯一的标准: