侧边栏壁纸
博主头像
孔子说JAVA博主等级

成功只是一只沦落在鸡窝里的鹰,成功永远属于自信且有毅力的人!

  • 累计撰写 285 篇文章
  • 累计创建 125 个标签
  • 累计收到 4 条评论

目 录CONTENT

文章目录

java基础之重写equals和hashcode方法

孔子说JAVA
2022-09-06 / 0 评论 / 0 点赞 / 25 阅读 / 6,455 字 / 正在检测是否收录...

hashCode是JDK根据对象的地址算出来的一个 int 数字(对象的哈希码值),代表了该对象在内存中的存储位置。在我们的日常开发或数据结构中有一个要求:两个对象如果使用equals比较为true 那么它们的hash值必须一样,所以我们重写equals方法的同时,一般都会重写hashCode方法。

1、equals和hashCode

1.1 equals()和hashCode()

hashCode() 方法是超类 Object 类提供的一个方法,所有类都可以对该方法进行重写。hashCode() 相等是两个对象相等的必要非充分条件。equals() 相等是两个对象相等的充分条件。重写 equals()方法一定要重写 hashCode()方法是为了提升效率,初步通过 hashCode() 判断是否相等,相等之后再通过 equals() 中的别的方式判断是否相等。

  • equals()方法,一般用来对两个对象的等价性进行判断。equal()相等的两个对象他们的 hashCode() 肯定相等,也就是用equal()对比是绝对可靠的。
  • hashCode()方法,当我们使用基于散列值的容器时,会使用该方法判断是否应该散列到同一位置。hashCode方法返回的是对象对地址的表现形式,十进制,是有hash算法算出来的。hashCode()方法给对象返回一个hashcode值。这个方法被用于hash tables,例如HashMap。hashCode()相等的两个对象他们的equal()不一定相等,也就是hashCode()不是绝对可靠的。

对于需要大量并且快速的对比的话如果都用equal()去做显然效率太低,所以解决方式是,每当需要对比的时候,首先用hashCode()去对比,如果hashCode()不一样,则表示这两个对象肯定不相等(也就是不必再用equal()去再对比了),如果hashCode()相同,此时再对比他们的equal(),如果equal()也相同,则表示这两个对象是真的相同了,这样既能大大提高了效率也保证了对比的绝对正确性。

1.2 可变与不可变类型

不可变数据类型: 当该数据类型的对应变量的值发生了改变,那么它对应的内存地址也会发生改变,对于这种数据类型,就称不可变数据类型。其中基本数据类型都是不可变数据类型,例如int,如果一个int类型的数据发生改变,那么它指向了内存中的另一个地址,但是需要注意的是java缓存了所有-128-127的值。对于不可变类型的equals()和hashCode()方法的重写比较简单。

  • 对于equals()方法,只要根据我们对等价性的规定,对其中的属性进行判断即可(不一定是全部的属性)。
  • 同理,重写hashCode()方法,只要对需要的值进行散列即可。

可变数据类型 :当该数据类型的对应变量的值发生了改变,那么它对应的内存地址不发生改变,对于这种数据类型,就称可变数据类型,当可变数据类型改变时它实际上是更改了内存中的内容。

  • 针对可变数据类型,为了保证行为等价性是一致的,就要用“==”来判断,只有指向同一个地址空间的两个变量,才认为是等价的,因为指向同一个地址空间,从一个变量处改变,另一个也跟着变;equals不需要重写。
  • 另外,如果重写了可变类型的equals()和hashCode()方法,那么在多线程的使用场景下,会造成一些问题。(这也是我们更倾向于使用不可变类型的原因。)
  • 当一个线程判断两个可变对象相同后,还为进行相应的操作时,若另一个线程改变了其中的一些属性,这就会造成一些意想不到的后果。

1.3 equals()方法

为保证程序健壮性,在重写 equals 方法时需满足以下情况:

  1. 自反性 : A.equals(A) 要返回 true。
  2. 对称性:如果 A.equals(B) 返回 true,则 B.equals(A) 也要返回 true。
  3. 传递性:如果 A.equals(B) 为 true,B.equals© 为 true,则 A.equals© 也要为 true, 相 当于如果 A = B, B = C ,那么 A = C。
  4. 一致性:只要 A、B 对象的状态没有改变,A.equals(B) 必须始终返回 true。
  5. A.equals(null) 要返回 false。

1.4 hashCode()的性质

  • 在一个Java应用的执行期间,如果一个对象提供给equals做比较的信息没有被修改的话,该对象多次调用hashCode()方法,该方法必须始终如一返回同一个integer。
  • 如果两个对象根据equals(Object)方法是相等的,那么调用二者各自的hashCode()方法必须产生同一个integer结果。
  • 并不要求根据equals(java.lang.Object)方法不相等的两个对象,调用二者各自的hashCode()方法必须产生不同的integer结果。然而,程序员应该意识到对于不同的对象产生不同的integer结果,有可能会提高hash table的性能。
  • 在重写equals()方法时,总要重写hashCode()方法,原因总结下有以下两点:
    1. 使用hashcode方法提前校验,可以避免每一次比对都调用equals方法,提高效率。
    1. 保证是同一个对象,如果重写了equals方法,而没有重写hashcode方法,会出现equals相等的对象,hashcode不相等的情况,重写hashcode方法就是为了避免这种情况的出现。

1.5 == 与 equals的区别

  • 如果两个引用类型变量使用==运算符,那么比较的是地址,它们分别指向的是否是同一地址的对象。结果一定是false,因为两个对象不可能存放在同一地址处。
  • 要求是两个对象都不是能空值,与空值比较返回false。
  • ==不能实现比较对象的值是否相同。
  • 所有对象都有equals方法,默认是Object类的equals,其结果与==一样。
  • 如果希望比较对象的值相同,必须重写equals方法。

2、重写hashCode和equals

在重写equals()后,一定要重写hashCode()方法。

  • equals相等,hashcode相等
  • hashcode相等,equals不一定相等

需要将对象放入HsahMap、HashSet等集合中的类需要重写HashCode和equals()方法。在集合中,比如HashSet中,要求放入的对象不能重复,怎么判定呢?

  • 首先会调用hashcode,如果hashcode相等,则继续调用equals,也相等,则认为重复。
  • 如果重写equals后,如果不重写hashcode,则hashcode就是继承自Object的,返回内存编码,这时候可能出现equals相等,而hashcode不等,你的对象使用集合时,就会等不到正确的结果。

重写hashCode()方法的基本原则:

  • 在程序运行时,同一对象多次调用hashCode()方法,应该返回相同的值
  • 当两个对象的equals()方法比较返回true时,则两个对象的hashCode()方法的返回值也相等
  • 对象中作equals()方法比较的Field(字段,属性),都应该用来计算hashCode()的返回值

没有重写hashCode()方法时

public class Person {
    private String name;
    private String idCard;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getIdCard() {
        return idCard;
    }
    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }

    public Person() {}

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

    public static void main(String[] args) {
        Person p1 = new Person("赵四", "41081234");
        Person p2 = new Person("赵四", "41081234");
        System.out.println("p1的hashCode是" + p1.hashCode());
        System.out.println("p2的hashCode是" + p2.hashCode());
    }
}

这段代码的运行结果是:

p1的hashCode是1163157884
p2的hashCode是1956725890

这段代码中,我们打印出两个对象的哈希值,我们看到Person这个类中并没有hashCode()方法,因为在Java的继承体系中,Object类是所有类的超类,也就是说实际上Person类是继承了Object类的,因此这里没有写hashCode()方法,那么调用的就是Object类的hashCode()方法了。

这个Object类中继承的hashCode()方法显然不适用于这个Person类。因为p1和p2这两个对象的属性值是完全一样的,那么从业务角度来说,这两个对象应该就是重复的,那么他们生成的哈希值也应该是一致的,而现在显然并不一致,因此我们需要为这个Person类重写hashCode()方法。

重写hashCode()方法后

public class Person {
    private String name;
    private String idCard;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getIdCard() {
        return idCard;
    }
    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }

    public Person() {}

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

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((idCard == null) ? 0 : idCard.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    
    public boolean equals(Object o) {
        if(this.hashCode() == o.hashCode()){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Person p1 = new Person("赵四", "41081234");
        Person p2 = new Person("赵四", "41081234");
        System.out.println("p1的hashCode是" + p1.hashCode());
        System.out.println("p2的hashCode是" + p2.hashCode());
    }
}

这段代码的运行结果为:

p1的hashCode是1301683616
p2的hashCode是1301683616

在我们重写hashCode()方法后,可以看到两个属性值完全相同的对象,他们的哈希值是相同的。从业务的角度来说,达到了这两个对象相同的目的。

为什么重写时要使用31?

@Override
public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((idCard == null) ? 0 : idCard.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
}

首先为了尽量让产生hashcode保持唯一,所以一定使用一个素数来做系数(这里的31),但为什么是31而不是别的素数呢?

先要明白为什么需要HashCode.每个对象根据值计算HashCode,这个code大小虽然不奢求必须唯一(因为这样通常计算会非常慢),但是要尽可能的不要重复,因此基数要尽量的大。另外,31 * N可以被编译器优化为左移5位后减1即31 * N = (N<<5)-1,有较高的性能。使用31的原因可能是为了更好的分配hash地址,并且31只占用5bits!所以从效率上它是2的5次减1,对计算机来说2的乘除操作只需要做位移操作,例如 * 32就是左移5位。也就是说31对计算机的角度来说运算更快、切占内存不多不少,而且形成惯例,虚拟机甚至都专门对他做了优化。所以常用31做系数算hashcode。

  • 31属于一个特殊的质数,任何数 乘以 31 就等于 这个数 * 2 的5次方 - 这个数本身
  • <<左移几位 表示 乘以 2 的几次方
  • >>右移几位 标识 除以 2 的几次方
  • n * 31 等价于 (n * 2 * 2* 2 * 2 * 2 - n) (n << 5) - n

3、应用实例

public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student() {
        super();
    }
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        // 这里使用==显示判断比较对象是否是同一对象
        if (this == obj)
            return true;
        if (!(obj instanceof Student))
            return false;
        // 对于任何非null的引用值x,x.equals(null)必须返回false
        if (obj == null)
            return false;
        // 通过 getClass 判断比较对象类型是否相等
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        // 引入java8 Objects 如果两者相等,返回true(含两者皆空的情形),否则比较两者值是否相等
        return Objects.equals(this.age, other.age) && Objects.equals(this.name, other.name);
    }	
}
0

评论区