重写equals的同时为何要重写hashCode?

 更新时间:2021-01-22 09:55:42   作者:佚名   我要评论(0)

结论


先直接上结论:
重写equals不一定要重写hashCode,得看情况。如果在没使用容器时其实是没必要的。
如果使用了HashMap等容器,并且使

结论

先直接上结论:

重写equals不一定要重写hashCode,得看情况。如果在没使用容器时其实是没必要的。

如果使用了HashMap等容器,并且使用了自定义对象作为Key是一定要重写的。

重写equals是为了在业务逻辑上判断实例之间是否相等。重写hascode是为了让集合快速判重。

hashCode()与 equals() 的规定:

1.如果两个对象相等,则 hashcode 一定也是相同的

2.两个对象相等,对两个 equals() 方法返回 true

3.两个对象有相同的 hashcode 值,它们也不一定是相等的

4.综上,equals() 方法被覆盖过,则 hashCode() 方法也必须被覆盖

5.hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode(),则该 class 的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)。

下面举个例子说明一定要重写。

当使用自定义类作为HashMap的Key时put时

如果只重写equals不重写hashCode会出现逻辑错误

先看下面的代码

public class Test {

  static class Order {
  
    private Long orderId;

    public Order(Long orderId) {
      this.orderId = orderId;
    }

    public Long getOrderId() {
      return orderId;
    }

    public void setOrderId(Long orderId) {
      this.orderId = orderId;
    }

    @Override
    public boolean equals(Object obj) {
      if (obj != null && !(obj instanceof Order)) {
        return false;
      }

      return Objects.equals(this.orderId, ((Order) obj).orderId);
    }

    @Override
    public String toString() {
      return "Order{" +
          "orderId=" + orderId +
          '}';
    }
  }

  public static void main(String[] args) {
    Map<Order, String> map = new HashMap<>();

    Order order1 = new Order(1000000001L);
    Order order2 = new Order(1000000001L);

    map.put(order1, "");
    map.put(order2, "");

    System.out.println(map);
  }
}

运行输出:

{Order{orderId=1000000001}=, Order{orderId=1000000001}=}

在代码中重写了equals方法,没重写hashCode方法。

equals重写的逻辑是:只要orderId相等那么这这两个对象就相等。

而从运行结果来看,两个orderId一致的对象却都成功put到了map中。这就是逻辑错误了,因为按照逻辑来说期望的结果应该只有一个Order在map中才对。

我们来看下HashMap的源码

只需要看写了注释的那个判断

public V put(K key, V value) {
  return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
   int h;
   return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
        boolean evict) {
  Node<K,V>[] tab; Node<K,V> p; int n, i;
  if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;
  // 通过hash算出索引 通过索引取值==null的话 直接直接插入到索引位置。
  if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);
  else {
    Node<K,V> e; K k;
    if (p.hash == hash &&
      ((k = p.key) == key || (key != null && key.equals(k))))
      e = p;
    else if (p instanceof TreeNode)
      e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
    else {
      for (int binCount = 0; ; ++binCount) {
        if ((e = p.next) == null) {
          p.next = newNode(hash, key, value, null);
          if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
            treeifyBin(tab, hash);
          break;
        }
        if (e.hash == hash &&
          ((k = e.key) == key || (key != null && key.equals(k))))
          break;
        p = e;
      }
    }
    if (e != null) { // existing mapping for key
      V oldValue = e.value;
      if (!onlyIfAbsent || oldValue == null)
        e.value = value;
      afterNodeAccess(e);
      return oldValue;
    }
  }
  ++modCount;
  if (++size > threshold)
    resize();
  afterNodeInsertion(evict);
  return null;
}

通过源码我们知道,只要hash码不一样的话就可以直接插入到数组中。然而正因为我们没重写hashCode方法,所以调用的是Object的hashCode方法。而Object的hashCode是使用对象在堆中的地址通过算法得出一个int类型的值,既然如此,那刚刚创建的两个对象的int类型的值肯定是不同的,所以两个Order都可以正常插入到数组中,从而出现了逻辑错误。

重写hashCode方法:

public class TestHash {

  static class Order {


    private Long orderId;

    public Order(Long orderId) {
      this.orderId = orderId;
    }

    public Long getOrderId() {
      return orderId;
    }

    public void setOrderId(Long orderId) {
      this.orderId = orderId;
    }

    @Override
    public boolean equals(Object obj) {
      if (obj != null && !(obj instanceof Order)) {
        return false;
      }

      return Objects.equals(this.orderId, ((Order) obj).orderId);
    }

    @Override
    public int hashCode() {
    	// 这里简单重写下  实际开发根据自己需求重写即可。
      return this.orderId.intValue() >> 2;
    }

    @Override
    public String toString() {
      return "Order{" +
          "orderId=" + orderId +
          '}';
    }
  }

  public static void main(String[] args) {
    Map<Order, String> map = new HashMap<>();

    Order order1 = new Order(1000000001L);
    Order order2 = new Order(1000000001L);

    map.put(order1, "");
    map.put(order2, "");

    System.out.println(map);
  }
}

再次运行输出:

{Order{orderId=1000000001}=}

我们简单看下源码(为了好理解,我只截取了重点代码):以put order2作为注释讲解。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
        boolean evict) {
  Node<K,V>[] tab; Node<K,V> p; int n, i;
  if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;
  // 重写hashCode之后两个对象的orderId相同,hashCode也肯定相同。
  // 通过hash算出索引 通过索引取值 有值不进入if。
  if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);
  else {
    Node<K,V> e; K k;
    // 由于重写了hashCode 旧对象的hashCode和新的肯定相等
    if (p.hash == hash &&
    // (k = p.key) == key == false 因为比较的是对象地址
    // (key != null && key.equals(k)) == true 因为重写了equals orderId相等则相等 
      ((k = p.key) == key || (key != null && key.equals(k))))
      // 保存旧Node
      e = p;
    .......
    if (e != null) { // existing mapping for key
      V oldValue = e.value;
      if (!onlyIfAbsent || oldValue == null)
      	// value覆盖旧Node的值
        e.value = value;
      afterNodeAccess(e);
      return oldValue;
    }
  }
  ........
}

所以order2覆盖了order1。这就是为什么当使用自定义对象作为HashMap的Key时如果重写了equals要同时hashCode。

反过来说:重写了hashCode,equals需要重写吗?

答案是要的,都要重写!

还是以上面代码重写的逻辑为例,假设hashCode相同的两个对象,且已经put order1在put时,hash相同,得出的索引也是相同,就可以取到order1,取到之后会继续使用equals比较,假设没有重写的话,那么就是对象地址比较,结果肯定是false,那么这个时候就发生了hash碰撞,也就形成了链表。

还有在map.get(key)时也是一样都会根据hashCode找,再判断equals。

为什么要判断equals呢?因为根据hashCode找到的是一个链表,需要根据equals在链表中找到Key相等的那个值。

什么场景会用到自定义类做key?

最常见的key是一个坐标,比如说在地图的某个坐标放置一个物体之类的。

public class Test {

  static class Coordinate {
    public Coordinate(int x, int y) {
      this.x = x;
      this.y = y;
    }

    private int x;
    private int y;

    public int getX() {
      return x;
    }

    public void setX(int x) {
      this.x = x;
    }

    public int getY() {
      return y;
    }

    public void setY(int y) {
      this.y = y;
    }
  }

  public static void main(String[] args) {
    Map<Coordinate, String> map = new HashMap<>();
    map.put(new Coordinate(22, 99), "手机");
    map.put(new Coordinate(44, 48), "电脑");
  }
}

总结

到此这篇关于重写equals的同时为何要重写hashCode的文章就介绍到这了,更多相关重写equals的同时重写hashCode内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
  • 重写hashCode()和equals()方法详细介绍
  • 为什么在重写 equals方法的同时必须重写 hashcode方法
  • why在重写equals时还必须重写hashcode方法分享
  • java中为何重写equals时必须重写hashCode方法详解
  • java中重写equals()方法的同时要重写hashcode()方法(详解)
  • java中重写equals和重写hashCode()
  • 如何在IDEA中对 hashCode()和 equals() 利用快捷键快速进行方法重写
  • Java重写equals及hashcode方法流程解析

相关文章

  • 重写equals的同时为何要重写hashCode?

    重写equals的同时为何要重写hashCode?

    结论 先直接上结论: 重写equals不一定要重写hashCode,得看情况。如果在没使用容器时其实是没必要的。 如果使用了HashMap等容器,并且使
    2021-01-22
  • 详解Java Slipped Conditions

    详解Java Slipped Conditions

    所谓Slipped conditions,就是说, 从一个线程检查某一特定条件到该线程操作此条件期间,这个条件已经被其它线程改变,导致第一个线程在该条
    2021-01-22
  • nodejs中使用worker_threads来创建新的线程的方法

    nodejs中使用worker_threads来创建新的线程的方法

    简介 之前的文章中提到了,nodejs中有两种线程,一种是event loop用来相应用户的请求和处理各种callback。另一种就是worker pool用来处理各种
    2021-01-22
  • 在idea中使用JaCoCo插件统计单元测试覆盖率的实现

    在idea中使用JaCoCo插件统计单元测试覆盖率的实现

    在后台工程师开发完新代码交给QA进行测试时,软件测试人员一般都会要求后台开发对单元测试的覆盖率达到一定的标准;例如我们的标准是分支覆盖
    2021-01-22
  • SpringCloud手写Ribbon实现负载均衡

    SpringCloud手写Ribbon实现负载均衡

    前言 前面我们学习了 SpringCloud整合Consul ,在此基础上我们手写本地客户端实现类似Ribbon负载均衡的效果。 注: order 模块调用者 记得关
    2021-01-22
  • 如何使用C#中的Lazy的使用方法

    如何使用C#中的Lazy的使用方法

    延迟初始化 是一种将对象的创建延迟到第一次需要用时的技术,换句话说,对象的初始化是发生在真正需要的时候才执行,值得注意的是,术语 延迟
    2021-01-22
  • 最优雅地整合 Spring & Spring MVC & MyBatis 搭建 Java 企业级应用(附源码)

    最优雅地整合 Spring & Spring MVC & MyBatis 搭建 Java 企业级应用(附源码)

    这里使用 Maven 项目管理工具构建项目 初始化项目 打开 Intellij IDEA,点击 Create New Project 选择 Maven 构建项目 选择 JDK 版本
    2021-01-22
  • Android使用TypeFace设置TextView的文字字体

    Android使用TypeFace设置TextView的文字字体

    在Android里面设置一个TextView的文字颜色和文字大小,都很简单,也是一个常用的基本功能。但很少有设置文字字体的,今天要分享的是通过Type
    2021-01-22
  • IDEA 单元测试覆盖技巧分享

    IDEA 单元测试覆盖技巧分享

    1.前言 通常情况下,项目经理or项目总监会分阶段的问测试负责人,本阶段的测试覆盖率是多少?在工作中,当被问到“如何提高代码质量”,回答
    2021-01-22
  • Java信号量全解析

    Java信号量全解析

    前言: Semaphore(信号量) 是一个线程同步结构,用于在线程间传递信号,以避免出现信号丢失(译者注:下文会具体介绍),或者像锁一样用
    2021-01-22

最新评论