为什么重写了 equals 还要重写 hashCode？

目录

• 1. 先说一下为什么要重写 equals 方法？
• 2. 再说为什么还要重写 hashCode 方法？

借鉴：https://blog.csdn.net/weixin_44061521/article/details/128194172

日期：2023年2月4日21:52:49

如有不足或不对的地方，欢迎指正错误。

先说结论：在 java 中，当往哈希(散列)集合中添加元素时，会先去判断 hashCode 值是否相同，如果不同，则直接插入。如果相同，才去用 equals 判断。

注意：

• 两个对象的 hashCode 值如果不同，则对象一定不同。

• 两个对象的 hashCode 值如果相同，则对象可能相同，也可能不同，需要用 equals 去比较。

先用 hashCode 去判断对象是否相同可以提升效率，避免直接用 euqals 判断节省了时间。

这也就是为什么用了 hashCode 之后还要用 equals 方法去判断。

下面展开说明一下：

1. 先说一下为什么要重写 equals 方法？

对于引用类型来说，如果不重写 equals 方法，即使调用 equals 方法，默认还是是通过 == 来比较两个对象的地址。

没有重写 equals 方法，Person 类会调用其父类 Object 的 equals 方法。

• Object 类的 equals 方法

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

但在实际业务中，我们都是通过 属性是否相等 来判断两个对象是否为同一个。

创建一个 Person 类用来测试，属性只有一个 name，方便测试：

• Person 类

public class Person {
   private String name;

   public Person() {
   }

   public Person(String name) {
      this.name = name;
   }

}

• 测试

public class MyTest {
	public static void main(String[] args) {
		Person person1 = new Person("张三");
		Person person2 = new Person("张三");
		System.out.println(person1.equals(person2)); // false
	}
}

Person 类中重写了 equals 方法之后，通过 name 属性来比较两个对象是否为同一个。

使用 idea 快捷键 Ctrl + insert 生成。

@Override
public boolean equals(Object o) {
   if (this == o) return true;
   if (o == null || getClass() != o.getClass()) return false;
   Person person = (Person) o;
   return Objects.equals(name, person.name);
}

测试：

public class MyTest {
   public static void main(String[] args) {
      Person person1 = new Person("张三");
      Person person2 = new Person("张三");
      System.out.println(person1.equals(person2)); // true
   }
}

以上就是为什么重写 equals 方法。

2. 再说为什么还要重写 hashCode 方法？

如果没有重写 hashCode 方法，当我们将对象存储在哈希（散列）集合中会出问题

先在 Person 类中重写 toString 方法方便输出对象内容

@Override
public String toString() {
   return "Person{" +
         "name='" + name + '\'' +
         '}';
}

Set 集合中存储三个同名的对象，输出查看集合的大小以及存储对象的内容

public class MyTest {
   public static void main(String[] args) {
      Person person1 = new Person("张三");
      Person person2 = new Person("张三");
      Person person3 = new Person("张三");

      Set<Person> personSet = new HashSet<>();
      personSet.add(person1);
      personSet.add(person2);
      personSet.add(person3);

      System.out.println(personSet.size());
      personSet.forEach(System.out::println);

   }
}

测试结果：

3
Person{name='张三'}
Person{name='张三'}
Person{name='张三'}

期待的应该存储是一个对象，但却存储了三个，HashSet 没有去重。

这就是没有重写 hashCode 方法造成的。

重写了 hashCode 方法之后

@Override
public int hashCode() {
   return Objects.hash(name);
}

测试结果：

1
Person{name='张三'}

这样就如我们所期待的那样，向集合中存储多个相同的对象，只保留一个。

我们可以在 personSet.add(person1); 处打上断点，Debug 点击下一步就可查看执行步骤了。

或者

1. 可以将 hashCode 写死返回 1，equals 写死返回 false，再测试可以发现集合中存储了四个对象
2. 可以将 hashCode 写死返回 1，equals 写死返回 true，再测试可以发现集合中只存储了一个对象