首页 > 软件编程 > Java > 关于重写equals()方法和hashCode()方法及其简单的应用

关于重写equals()方法和hashCode()方法及其简单的应用

福牛 4月 06, 2023 56 0

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

最近看了学习了集合的简单的知识，碰到了讲解 Set 的部分，感觉很好奇，
这里对于 Set集合 的特点很感兴趣，Set集合判断两个元素相等的标准是两个对象通过 equals() 方法比较相等，并且两个对象的 hashCode() 方法返回值相等。
以后涉及到于 Set集合相关的应用，这个应该是必须掌握的基础知识。所以这里先了解一波比较好。

重写 equals() 方法

网上的知识有些可能是错误的，关于 equals() 方法的理解，大家讨论不一样。
这里以 算法（第4版）为准吧。
两个对象相等意味着什么？如果我们用相同类型的两个引用变量a和b进行等价性测试（a==b）,我们检测的是它们的标识是否相同，即引用是否相同。Java中有一些内置的实现，它们都改写了 equals() 方法，但是当我们自定义自己的数据类型时，需要重载 equals() 方法。

Java 约定equals() 方法必须是一种等价性关系。它必须具有：

自反性，x.equals(x) 为 true；
对称性，当且仅当 y.equals(x) 为 true，x.equals(y) 为 true;
传递性，如果 x.equals(y) 和 y.equals(z) 均为 true， x.equals(z) 也将为 true。
并且，它必须接受一个 Object 为参数并满足以下性质：
一致性，当两个对象均未被修改时，反复调用 x.equals(y)
总是会返回相同的值；
非空性，x.equals(null) 总是返回 false。

这里的自反性、对称性和传递性在离散数学中有介绍，感兴趣的可以去探究！

具体步骤为：

如果对象的引用和参数对象的引用相同，返回 true。这项测试在成立时能够免去其他所有的测试工作。如果参数为空（null），根据约定返回 false （还可以避免在下面的代码中使用空引用）。如果两个对象的类不同，返回false。要得到一个对象的类，可以使用 getClass() 方法。请注意我们会使用 == 判断 Class类型的对象是否相等，因为同一种类型的所有对象的 getClass() 方法一定能够返回相同的引用。 将参数对象的类型从 Object 转换到 当前类（因为前一项测试已经通过了，这种转换必然成功）。如果任意实例变量的值不相同，返回 false。（这最后一步才是每个类的不同的，前面的都是相同的步骤。）

代码示例：
对于任意类来说，前面三个判断是相同的，对于自己希望的实现，通过实例变量的值进行比较。

  1.      @Override
  2.      public boolean equals(Object x) {
  3.          if (this == x) return true;
  4.          if (x == null) return false;
  5.          if (this.getClass() != x.getClass()) return false;
  6.          Cat cat = (Cat)x;
  7.          if (this.name != cat.getName()) return false;
  8.          if (this.age != cat.getAge()) return false;
  9.          return true;
  10.      }

重写 hashCode() 方法

Object 类的hashCode() 会返回当前对象的 hash 值，如果不重写 hashCode() 默认是使用 Object 类的 hashCode() 方法，它本身是一个 native 方法，即不是使用 Java 语言实现的。
补充一点 hash 算法的知识：
hash 算法的功能是：保证快速查找被检索的对象，它是非常快的，在不发生 hash 冲突的情况下，时间复杂度为 O(1)。

如果重写了 hashCode()，但是还想要知道对象的 hash 值，可以使用下面这个方法 System.identityHashCode(x)，如果是否重写对象的 hashCode() 方法，它都返回默认的 hashCode，就是父类 Object 继承的 hashCode() 方法返回值。

jdk 1.7 以后提供了一个 Objects 工具类，它提供了一个重写 hashCode 的方法，它的参数是可变参数。

  1.      public static int hash(Object… values) {
  2.          return Arrays.hashCode(values);
  3.      }

它本身还是借助于 Arrays 这个工具类的方法：

  1.      public static int hashCode(Object a[]) {
  2.          if (a == null)
  3.              return 0;
  4.          int result = 1;
  5.          for (Object element : a)
  6.              result = 31 * result + (element == null ? 0 : element.hashCode());
  7.          return result;
  8.      }

本来重写 hashCode() 需要使用上面这个 Arrays 工具类里面的方法，但是我们有了这个工具类，就 可以很方便了，这里重写 hashCode() 的方法很简单了（复杂的部分，已经被封装了，哈哈！）:

  1. @Override
  2.      public int hashCode() {
  3.          return Objects.hash(name,age);
  4.      }

那我们来测试一下吧

测试实体类 Cat

  1. package com;
  2. import java.util.Objects;
  3.  
  4. public class Cat implements Comparable<Cat>{
  5.      private String name;
  6.      private int age;
  8.      public Cat() {}
  10.      public Cat(String name, int age) {
  11.          this.name = name;
  12.          this.age = age;
  13.      }
  14.  
  15.      public String getName() {
  16.          return name;
  17.      }
  18.  
  19.      public void setName(String name) {
  20.          this.name = name;
  21.      }
  22.  
  23.      public int getAge() {
  24.          return age;
  25.      }
  26.  
  27.      public void setAge(int age) {
  28.          this.age = age;
  29.      }
  30.  
  31.      @Override
  32.      public String toString() {
  33.          return “Cat [name=” + name + “, age=” + age + “]”;
  34.      }
  36.      @Override
  37.      public boolean equals(Object x) {
  38.          if (this == x) return true;
  39.          if (x == null) return false;
  40.          if (this.getClass() != x.getClass()) return false;
  41.          Cat cat = (Cat)x;
  42.          if (this.name != cat.getName()) return false;
  43.          if (this.age != cat.getAge()) return false;
  44.          return true;
  45.      }
  47.      @Override
  48.      public int hashCode() {
  49.          return Objects.hash(name,age);
  50.      }
  51.  
  52.      @Override
  53.      public int compareTo(Cat o) {
  54.          return o.name.compareTo(name);
  55.      }
  56. }
  57.  

测试类

  1. package com;
  2.  
  3. import java.util.HashSet;
  4. import java.util.Set;
  5.  
  6. public class Test {
  7.      public static void main(String[] args) throws Exception {
  8.          Set<Cat> cats = new HashSet<>();
  9.          Cat cat1 = new Cat(“小猫”,3);
  10.          Cat cat2 = new Cat(“小猫”,3);
  11.          System.out.println(“cat1 == cat2: “+(cat1 == cat2));
  12.          cats.add(cat1);
  13.          cats.add(cat2);
  14.          System.out.println(“cats.size()：”+cats.size());
  15.          cats.forEach(System.out::println);
  16.      }
  17. }

测试结果

-1

说明：可以看出来 cat1 和 cat2 不是一个对象，因为两种的引用不一样，但是对于这种属性完全一样的对象，在集合中我们希望它是被认为是相同的，所以就必须 重写 equals()方法 和 hashCode() 方法。从结果可以看出来，将cat1 和 cat2 加入集合后，集合的 size方法返回值为 1，并且遍历集合也只有一个元素，说明了 重写的方法起作用了。

扩展部分 TreeSet 的简单应用

Comparable 和 Comparator 相关知识

TreeSet 会自动对存入的元素进行排序，是一种很有用的集合。它本身是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。关于TreeSet 本身这里不做过多介绍，我也只是在学习中。

测试类

  1. package com;
  2.  
  3. import java.util.Set;
  4. import java.util.TreeSet;
  5.  
  6. public class Client {
  7.  
  8.      public static void main(String[] args) {
  9.          Cat cat = null;
  10.          Set<Cat> cats = null;
  11.          //使用 Comparable 接口进行排序
  12.          cats = new TreeSet<>();
  13.          for (int i = 0; i < 10; i++) {
  14.              cat = new Cat(“小猫”+i, i);
  15.              cats.add(cat);
  16.          }
  17.          System.out.println(“————-Comparable—————“);
  18.          cats.forEach(System.out::println);
  19.          cats.clear(); //注意清空集合。
  21.          //使用 Comparator 接口进行排序
  22.          //Comparator<Cat> c = (e1,e2)->e1.getAge()-e2.getAge();
  23.          cats = new TreeSet<>((e1,e2)->e1.getAge()-e2.getAge());
  24.          for (int i = 0; i < 10; i++) {
  25.              cat = new Cat(“小猫”+i, i);
  26.              cats.add(cat);
  27.          }
  28.          System.out.println(“————-Comparator—————“);
  29.          cats.forEach(System.out::println);
  30.          //故意将方法执行两遍，这样是为了检验 equals()方法和 hsahCode()方法。
  31.          for (int i = 0; i < 10; i++) {
  32.              cat = new Cat(“小猫”+i, i);
  33.              cats.add(cat);
  34.          }
  35.          System.out.println(“————-equals() 和 hashCode() —————“);
  36.          cats.forEach(System.out::println);
  37.      }
  38. }
  39.  

运行结果

-2

说明
这里注意最下面，我进行了 equals() 和 hashCode() 方法的测试，重复加入集合的元素，会被认为是相同的元素，所以遍历元素之后还是原来的元素。前面的内容就是对于 Comparable 和 Comparator 的简单应用，感兴趣的可以点击上面的链接了解一下。

到此这篇关于关于重写equals()方法和hashCode()方法及其简单的应用的文章就介绍到这了,更多相关重写equals()和hashCode()及应用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论