重写object中的hashcode和equals方法

最新推荐文章于 2021-10-01 08:52:55 发布

huaguoming

最新推荐文章于 2021-10-01 08:52:55 发布

阅读量2.6k

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/huaguoming/article/details/8135817

版权

java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

覆盖equals方法

1. Object中对equals、hashcode方法的实现

(1) 在object中直接用 ==比较引用是不是指向同一个对象

(2) 直接返回对象在内存中的地址

2. 什么情况下不用覆盖equals方法

(1) 一个类的实例在本质上都是不同的。比如说Thread对象，每个Thread对象都是不同的。

(2) 不用去关心一个类的两个对象是不是逻辑上是相等的。

(3) 超类中已经覆盖了equals方法，而在子类中从超类继承过来的equals方法对于子类来说也是适用的。

(4) 私有类或者package类，这些类能保证外部不会调用equals方法，所以不需要去重写。

3. 什么情况下需要覆盖equals方法

(1) 逻辑上需要比较相等的类的对象，比如说double、float、PhoneNumber等。

这些类，我们归结为需要在程序中比较逻辑上相等性的value类。

(2) 需要作为key键值放入HashMap,HashSet,HashTable中的类的对象。因为这Hash集合中需要比较类的相等性。这时候不仅需要覆盖equals方法，还需要覆盖HashCode方法

4. 为什么要覆盖equals方法

(1) 逻辑上必须要比较类对象的相等性。

(2) 需要把对象放在Hash集合中。

5. 覆盖equals方法需要遵循的原则

5.1 覆盖equals后，对象必须要满足的特性

(1) 自反性

(2) 对称性

x.equals(y)为true，那么y.equals(x)也一定是true

(3) 传递性

x.equals(y)为true，y.equals(z)为true，那么x.equals(z)也要true

(4) 一致性

(5) 对于null来说,x.equals(null)一定要false

5.2 对称性

package equal.and.hashcode;

import java.util.ArrayList;

import java.util.List;

public class CaseInsensitiveString {

private final Strings;

publicCaseInsensitiveString(String s) {

if (s ==null)

thrownew NullPointerException();

this.s = s;

}

// Broken - violatessymmetry!

@Override

/**

* 违法对称性

* 如果x.equals(y) ==true;那么y.equals(x)也要true

public booleanequals(Object o) {

if (oinstanceof CaseInsensitiveString)

returns.equalsIgnoreCase(((CaseInsensitiveString) o).s);

if (oinstanceof String) // One-way interoperability!

returns.equalsIgnoreCase((String) o);

returnfalse;

}

public static voidmain(String[] args){

CaseInsensitiveStringcis = new CaseInsensitiveString("Hua");

String s ="hua";

System.out.println(s.equals(cis));

//为什么是true，因为CaseInsensitiveStringequals方法直接用内部域

String s来判断；而在String 类中，根本不知道有CaseInsensitiveString

System.out.println(cis.equals(s));

}

修正：

public boolean equals(Object o) {

if(!(o instanceofCaseInsensitiveString))

return false;

CaseInsensitiveStringother = (CaseInsensitiveString) o;

return other.s == s;

}

5.3 传递性

(1) 第一种情况，子类不覆盖父类的equals方法

这种情况下，相当于子类中新添加的域z不在比较。只要他们位置x,y是相同的，就表示逻辑上是相同的。

父类：

packageequal.and.hashcode;

public class Point {

private int x;

private int y;

public Point(int x,int y){

this.x = x;

this.y = y;

}

@Override

public boolean equals(Object obj) {

if(!(obj instanceof Point))

return false;

Point p =(Point) obj;

return p.x == x && p.y == y;

}

子类：

packageequal.and.hashcode;

public class ColorPoint extends Point{

private int z;

public ColorPoint(int x, int y,int z) {

super(x, y);

this.z = z;

}

public static void main(String[]args){

ColorPoint c1 = new ColorPoint(1,1,2);

Point p = new Point(1,1);

ColorPoint c2 = new ColorPoint(1,1,6);

//违反对称性

System.out.println(c1.equals(p));

System.out.println(p.equals(c2));

System.out.println(c1.equals(c2));

}

(2) 第一种情况，子类覆盖equals方法

情况1：

public boolean equals(Object obj) {

if(!(obj instanceof ColorPoint ))

return false;

return super.equals(obj) && ((ColorPoint) obj).z == z;

}

比较：

ColorPoint c1 = new ColorPoint(1,1,2);

Point p = new Point(1,1);

//违反对称性

System.out.println(c1.equals(p)); --调用子类的equals，返回false

System.out.println(p.equals(c2)); --调用父类的equals，返回true

情况2：

@Override

public boolean equals(Object obj){

//obj不是Point的对象

if(!(obj instanceof Point))//1

return false;

//obj只是Point的对象

if(!(obj instanceof ColorPoint))//2

return super.equals(obj);

//obj是ColorPoint的对象

return super.equals(obj)&& ((ColorPoint) obj).z == z;//3

}

用equals比较：

ColorPoint c1 = new ColorPoint(1,1,2);

Point p = new Point(1,1);

ColorPoint c2 = new ColorPoint(1,1,6);

//违反了传递性

System.out.println(c1.equals(p));--调用子类的 equals，走到2

System.out.println(p.equals(c2));--调用父类的equals

System.out.println(c1.equals(c2));--调用子类的方法，走到3

最后，发现违法了传递性

继承一个父类时，既想在子类中添加新的域，又想保证equals约定，实现上很困难的。

修正：

利用组合能很容易的修正：

package equal.and.hashcode;

import java.util.HashMap;

import java.util.Map;

public class ColorPoint2 {

private Point point;

private int z;

public ColorPoint2(Point p,intz){

this.point = p;

this.z = z;

}

@Override

public boolean equals(Object obj){

if(!(obj instanceofColorPoint2))

return false;

ColorPoint2 other =(ColorPoint2) obj;

returnother.point.equals(point) && other.z == z;

}

public static void main(String[]args){

ColorPoint2 c1 = newColorPoint2(new Point(1,1),3);

ColorPoint2 c2 = newColorPoint2(new Point(1,1),3);

ColorPoint2 c3 = newColorPoint2(new Point(1,1),3);

System.out.println(c1.equals(c2));

System.out.println(c2.equals(c3));

System.out.println(c1.equals(c3));

}

6. 覆盖equals的步骤：

(1) 用==判断是不是指向同一个对象

(2) 用instanceof判断参数是不是正确的类型

(3) 强制转换成正确的类型

(4) 用逻辑上判断相等的关键域来判断相等。

Float用floatToIntBit转换成int在比较

Double用doubleToLongBit转换成long在用==比较

对于引用要把关键域一一做比较

对于数组要把数组中的每个元素做比较

对于Null的处理

(field == o.field || (field != null &&field.equals(o.field)))

覆盖完equals方法后，一定要覆盖hashcode方法

Hashcode覆盖

1. Hashcode的作用

1.1 hashCode() 是用来产生哈希玛的，而哈希玛是用来在散列存储结构中确定对象的存储地址的。

1.2 Object中默认的equals和HashCode实现

(1) 默认情况下equals比较引用是不是指向同一个对象

(2) 默认情况下HashCode返回对象内存地址的整数值

对象需要比较逻辑上相等的话，需要重写equals和HashCode方法。

重写hashcode是为了产生哈希玛，而哈希玛是用来在散列存储结构中确定对象的存储地址的。比如hashSet,hashMap这类结构。

如果两个对象hashcode相等，那么需要比较equals。

1.3 HashSet中的hashCode和equals

在将对象存入HashSet中时，通过被存入对象的 hashCode() 来确定对象在 HashSet中的存储地址，通过equals()来确定存入的对象是否重复。如果不去重写equals和hashcode方法的话，即使两个对象内容相同，但是hashcode一定不同，equals比较这两个对象一定不同。也就说，在HashSet中保存了逻辑上相同的两个对象。

所以需要存入HashSet并且需要比较逻辑上相等的两个对象需要同时重写equals和hashcode方法。

需满足以下条件：

Equals比较两个对象相等的，他们的hashcode也相同。

存：

满足这个条件在向HashSet中存放对象的时候，根据对象的hashcode定位到应该把这个对象放在HastSet的那个位置，如果这个位置没有对象，直接存放。如果有对象需要用equals比较。

取：

从hashset中取对象的时候，直接根据hashcode就能定位到HashSet保存这个对象的位置，不需要每次都去一一用equals方法比较对象是不是相等了。

Java中对HashSet是用HashMap来实现的。

1.4 HashMap中的hashCode和equals

HashMap中根据key的hashCode来保存value。

hashCode()方法使用来提高Map里面的搜索效率的,Map会根据不同的hashCode()来放在不同的桶里面,Map在搜索一个对象的时候先通过 hashCode()找到相应的桶,然后再根据equals()方法找到相应的对象.要正确的实现Map里面查找元素必须满足一下两个条件:
(1)当obj1.equals(obj2)为true时obj1.hashCode()== obj2.hashCode()必须为true
(2)当obj1.hashCode() == obj2.hashCode()为false时obj.equals(obj2)必须为false