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

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

结论

先直接上结论：

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

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

重写equals是为了在业务逻辑上判断实例之间是否相等。重写

http://

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 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[] tab; Node 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 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)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 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[] tab; Node 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 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时如

VKWVtq

果重写了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 map = new HashMap<>();

map.put(new Coordinate(22, 99), "手机");

map.put(new Coordinate(44, 48), "电脑");

}

}

总结

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。