Java hashCode() 与 equals()详解

最新推荐文章于 2024-05-28 14:00:00 发布

lollipop98

最新推荐文章于 2024-05-28 14:00:00 发布

阅读量129

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/weixin_38896998/article/details/86496872

版权

Java基础专栏收录该内容

11 篇文章 11 订阅

订阅专栏

本篇博文的内容主要解决下面几个问题：

equals() 的作用是什么？
equals() 与 == 的区别是什么？
hashCode() 的作用是什么？
hashCode() 和 equals() 之间有什么联系？

equals() 的作用

equals() 是用来判断两个对象是否相等的方法。

equals() 定义在Object类中，通过判断两个对象的地址是否相等(是否是同一个对象)来区分它们是否相等。源码如下：

	public boolean equals(Object obj) {
        return (this == obj);
    }

既然Object类中定义了equals()方法，这就意味着所有的Java类都实现了equals()方法，所有的类都可以通过equals()去比较两个对象是否相等。但是，我们已经说过，使用默认的“equals()”方法，等价于“==”方法。因此，我们通常会重写equals()方法：若两个对象的内容相等，则equals()方法返回true；否则，返回false。

下面根据类是否覆盖equals()方法，将它分为2类：

若某个类没有覆盖equals()方法，当它的通过equals()比较两个对象时，实际上是比较两个对象是不是同一个对象。这时，等价于通过“==”去比较这两个对象。
我们可以覆盖类的equals()方法，来让equals()通过其它方式比较两个对象是否相等。通常的做法是：若两个对象的内容相等，则equals()方法返回true；否则，返回false。

没有覆盖equals()方法的情况

public class EqualsTest1 {

    public static void main(String[] args) {
        // 新建2个相同内容的Person对象，
        // 再用equals比较它们是否相等
        Person p1 = new Person("a", 20);
        Person p2 = new Person("a", 20);
        System.out.println(p1.equals(p2));
    }

    private static class Person {
        private int age;
        private String name;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
}

很明显结果为false

结果分析：

我们通过 p1.equals(p2) 来比较p1和p2是否相等时。实际上调用的是p1==p2，它是比较p1和p2是否是同一个对象。
而由 p1 和 p2 的定义可知，它们虽然内容相同；但它们是两个不同的对象！因此，返回结果是false。

覆盖equals()方法的情况

import java.util.Objects;

public class Demo {

    public static void main(String[] args) {
        // 新建2个相同内容的Person对象，
        // 再用equals比较它们是否相等
        Person p1 = new Person("a", 20);
        Person p2 = new Person("a", 20);
        System.out.println(p1.equals(p2));
    }

    private static class Person {
        private int age;
        private String name;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }
    }
}

此时结果变为true。
结果分析：

我们重写了Person的equals()函数：当两个Person对象的 name 和 age 都相等，则返回true。因此，运行结果返回true。

讲到这里，顺便说一下java对equals()的要求。有以下几点：

对称性：如果x.equals(y)返回是true，那么y.equals(x)也应该返回是true。
反射性：x.equals(x)必须返回是true。
类推性：如果x.equals(y)返回是true，而且y.equals(z)返回是true，那么z.equals(x)也应该返回是"true"。
一致性：如果x.equals(y)返回是true，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是true。
非空性，x.equals(null)，永远返回是false；x.equals(和x不同类型的对象)永远返回是false。

equals() 与 == 的区别是什么？

== : 它的作用是判断两个对象的地址是不是相等。即判断两个对象是不试同一个对象。
equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
1. 类没有覆盖equals()方法。则通过equals()比较该类的两个对象时，等价于通过“==”比较这两个对象。
2. 类覆盖了equals()方法。一般我们都通过覆盖equals()方法来实现判断两个对象的内容是否相等的操作；若它们的内容相等，则返回true。

下面，通过示例比较它们的区别。

import java.util.Objects;

public class Demo {

    public static void main(String[] args) {
        // 新建2个相同内容的Person对象，
        // 再用equals比较它们是否相等
        Person p1 = new Person("a", 20);
        Person p2 = new Person("a", 20);
        System.out.println(p1.equals(p2));
        System.out.println(p1 == p2);
    }

    private static class Person {
        private int age;
        private String name;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }
    }
}

运行结果：true false

结果分析：

p1.equals(p2) 这是判断p1和p2的内容是否相等。因为Person覆盖equals()方法，而这个equals()是用来判断p1和p2的内容是否相等，恰恰p1和p2的内容又相等；因此，返回true。
"p1==p2"这是判断p1和p2是否是同一个对象。由于它们是各自新建的两个Person对象；因此，返回false。

hashCode() 的作用

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 定义在Object类中，这就意味着Java中的任何类都包含有hashCode() 方法。虽然，每个Java类都包含hashCode() 方法。但是，仅仅当创建某个类的散列表时，该类的hashCode() 才有用，hashCode()确定了该类的每一个对象在散列表中的位置；其它情况下(例如，创建类的单个对象，或者创建类的对象数组等等)，类的hashCode() 都没有作用。

也就是说：hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

OK！至此，我们搞清楚了：hashCode()的作用是获取散列码。但是，散列码是用来干什么的呢？为什么散列表需要散列码呢？

为了能理解后面的内容，这里简单的介绍一下散列码的作用。

我们都知道，散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！
散列表的本质是通过数组实现的。当我们要获取散列表中的某个“值”时，实际上是要获取数组中的某个位置的元素。而数组的位置，就是通过“键”来获取的；更进一步说，数组的位置，是通过“键”对应的散列码计算得到的。

下面，我们以HashSet为例，来深入说明hashCode()的作用。

假设，HashSet中已经有1000个元素。当插入第1001个元素时，需要怎么处理？因为HashSet是Set集合，它不允许有重复元素。
将第1001个元素逐个的和前面1000个元素进行比较？显然，这个效率是相等低下的。散列表很好的解决了这个问题，它根据元素的散列码计算出元素在散列表中的位置，然后将元素插入该位置即可。对于相同的元素，自然是只保存了一个。

由此可知，若两个元素相等，它们的散列码一定相等；但反过来确不一定。在散列表中：

如果两个对象相等，那么它们的hashCode()值一定要相同；
如果两个对象hashCode()相等，它们并不一定相等。

注意：这是在散列表中的情况。在非散列表中一定如此！注意：这是在散列表中的情况。在非散列表中一定如此！

hashCode() 和 equals() 的关系

接下来，我们讨论另外一个话题。网上很多文章将 hashCode() 和 equals 关联起来，有的讲的不透彻，有误导读者的嫌疑。在这里，我自己梳理了一下 hashCode() 和 equals()的关系。

我们以“类的用途”来将hashCode() 和 equals()的关系分2种情况来说明。
1. 不会创建类对应的散列表
这里所说的“不会创建类对应的散列表”是说：我们不会在HashSet, Hashtable, HashMap等本质是散列表的数据结构中，用到该类。例如，不会创建该类的HashSet集合。
在这种情况下，该类的hashCode() 和 equals() 没有半毛钱关系的！
这种情况下，equals() 用来比较该类的两个对象是否相等。而hashCode() 则根本没有任何作用，所以，不用理会hashCode()。

下面，我们通过示例查看类的两个对象相等以及不等时hashCode()的取值

import java.util.Objects;

public class Demo {

    public static void main(String[] args) {
        Person p1 = new Person("a", 20);
        Person p2 = new Person("a", 20);
        Person p3 = new Person("a", 30);
        System.out.println("p1.equals(p2) = " + p1.equals(p2) + ", p1.hashCode() = " + p1.hashCode() + ", p2.hashCode() = " + p2.hashCode());
        System.out.println("p1.equals(p3) = " + p1.equals(p3) + ", p1.hashCode() = " + p1.hashCode() + ", p3.hashCode() = " + p3.hashCode());
    }

    private static class Person {
        private int age;
        private String name;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }
    }
}

运行结果：

p1.equals(p2) = true, p1.hashCode() = 1169863946, p2.hashCode() = 1901116749
p1.equals(p3) = false, p1.hashCode() = 1169863946, p3.hashCode() = 2131949076
从结果也可以看出：p1和p2相等的情况下，hashCode()也不一定相等。

2. 会创建类对应的散列表
这里所说的“会创建类对应的散列表”是说：我们会在HashSet, Hashtable, HashMap等等这些本质是散列表的数据结构中，用到该类。例如，会创建该类的HashSet集合。
在这种情况下，该类的hashCode() 和 equals() 是有关系的：

如果两个对象相等，那么它们的hashCode()值一定相同。这里的相等是指，通过equals()比较两个对象时返回true。
如果两个对象hashCode()相等，它们并不一定相等。因为在散列表中，hashCode()相等，即两个键值对的哈希值相等。然而哈希值相等，并不一定能得出键值对相等。补充说一句：“两个不同的键值对，哈希值相等”，这就是哈希冲突。

此外，在这种情况下。若要判断两个对象是否相等，除了要覆盖equals()之外，也要覆盖hashCode()函数。否则，equals()无效。
例如，创建Person类的HashSet集合，必须同时覆盖Person类的equals() 和 hashCode()方法。如果单单只是覆盖equals()方法，我们会发现，equals()方法没有达到我们想要的效果。

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class EqualsTest1 {

    public static void main(String[] args) {
        Person p1 = new Person("a", 20);
        Person p2 = new Person("a", 20);
        Person p3 = new Person("a", 30);
        Set<Person> set = new HashSet<>();
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println("p1.equals(p2) = " + p1.equals(p2) + ", p1.hashCode() = " + p1.hashCode() + ", p2.hashCode() = " + p2.hashCode());
        System.out.println("p1.equals(p3) = " + p1.equals(p3) + ", p1.hashCode() = " + p1.hashCode() + ", p3.hashCode() = " + p3.hashCode());
        System.out.println("set = " + set);
    }

    private static class Person {
        private int age;
        private String name;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }

        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
}

运行结果：

p1.equals(p2) = true, p1.hashCode() = 1060830840, p2.hashCode() = 2137211482
p1.equals(p3) = false, p1.hashCode() = 1060830840, p3.hashCode() = 920011586
set = [Person{age=20, name=‘a’}, Person{age=30, name=‘a’}, Person{age=20, name=‘a’}]

结果分析：

我们重写了Person的equals()。但是，很奇怪的发现：HashSet中仍然有重复元素：p1 和 p2。为什么会出现这种情况呢？
这是因为虽然p1 和 p2的内容相等，但是它们的hashCode()不等；所以，HashSet在添加p1和p2的时候，认为它们不相等。

下面，我们同时覆盖equals() 和 hashCode()方法。

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class EqualsTest1 {

    public static void main(String[] args) {
        Person p1 = new Person("a", 20);
        Person p2 = new Person("a", 20);
        Person p3 = new Person("a", 30);
        Set<Person> set = new HashSet<>();
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println("p1.equals(p2) = " + p1.equals(p2) + ", p1.hashCode() = " + p1.hashCode() + ", p2.hashCode() = " + p2.hashCode());
        System.out.println("p1.equals(p3) = " + p1.equals(p3) + ", p1.hashCode() = " + p1.hashCode() + ", p3.hashCode() = " + p3.hashCode());
        System.out.println("set = " + set);
    }

    private static class Person {
        private int age;
        private String name;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

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

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }

        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
}

运行结果：

p1.equals(p2) = true, p1.hashCode() = 1678, p2.hashCode() = 1678
p1.equals(p3) = false, p1.hashCode() = 1678, p3.hashCode() = 1988
set = [Person{age=30, name=‘a’}, Person{age=20, name=‘a’}]

结果分析：

这下，equals()生效了，HashSet中没有重复元素。
比较p1和p2，我们发现：它们的hashCode()相等，通过equals()比较它们也返回true。所以，p1和p2被视为相等。
比较p1和p3，我们发现：它们的hashCode()不相等，所以，p1和p4被视为不相等。

lollipop98

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java hashCode() 与 equals()详解

本篇博文的内容主要解决下面几个问题：equals() 的作用是什么？equals() 与 == 的区别是什么？hashCode() 的作用是什么？hashCode() 和 equals() 之间有什么联系？equals() 的作用equals() 是用来判断两个对象是否相等的方法。equals() 定义在Object类中，通过判断两个对象的地址是否相等(是否是同一个对象)来区分...
复制链接

扫一扫

专栏目录