首页 > 软件编程 > Java > Java ==,equals()与hashcode()的使用

Java ==,equals()与hashcode()的使用

福牛 5月 23, 2023 8 0

==，equals()与hashcode()

“==”

在讲解之前，我们是怎么接触到==的，我们在作比较时经常用到 ==, 这个符号常用作基本类的数据。

==运算符通常用于比较基本数据类型（如int、long、double等）和枚举类型的值是否相等，而对于对象类型，==运算符用于比较它们的引用是否相等，即它们是否指向同一个对象。

思考一个问题，为什么我们一般不使用==来比较对象，如果两个对象的引用相同，即它们指向同一个对象，那么使用==运算符比较它们的引用会返回true，因为它们确实指向同一个对象。在这种情况下，两个对象的内容自然是相同的，因为它们是同一个对象。

那为啥我们不直接使用==去比较对象， 而要麻烦的使用其它的办法，

因为: 我们比较对象不是想看它的引用是否相同，而是里面的属性是否相同

在这种情况下，使用==运算符比较两个对象的引用并不能判断它们的内容是否相同，因为两个不同的对象可能具有相同的属性值，但它们的引用不同。因此，在比较对象是否相同时，应该根据对象的语义来实现equals()方法，而不是使用==运算符。

  1. public class Main {
  2.      public static void main(String[] args) {
  3.          int a = 5;
  4.          int b = 5;
  5.          int c = 6;
  6.          System.out.println(a==b); // true
  7.          System.out.println(a==c); // false
  8.          Person p1 = new Person(“hhh”, 15);
  9.          Person p2 = new Person(“hhh”, 15);
  10.          // 属性相同，但引用不同。按照常理应该被认作是相同的。实际却是不同的
  11.          System.out.println(p1 == p2); // false
  12.      }
  13. }
  14. class Person{
  15.      String name;
  16.      Integer age;
  17.      Person(String name, Integer age){
  18.          this.age = age;
  19.          this.name = name;
  20.      }
  21. }

equals()方法

equals()方法是Object类中的方法，它仅仅是地址的比较，因此只能比较两个类是否是同一个类，而不能比较属性是否相同，因此，我们比较对象一般都会重写equals()方法

  1. public class Point {
  2.      private int x;
  3.      private int y;
  4.      public Point(int x, int y) {
  5.          this.x = x;
  6.          this.y = y;
  7.      }
  8.      // getters and setters
  9.      @Override
  10.      public boolean equals(Object obj) {
  11.          return (this == obj);
  12.      }
  13. }

如果一个类的属性包含基本数据类型和引用数据类型，那么这些属性值相同，但它们的引用地址也不一定相同。此时，必须重写equals()方法，根据对象的语义来进行比较，才能得到正确的结果。

列表中的使用

在Java中，列表类（如List）通常用来存储一组对象，当我们需要在列表中查找某个对象时，通常需要调用列表的contains()方法或indexOf()方法。这些方法会使用对象的equals()方法来比较对象是否相等。

它是通过比较对象的属性值从而去列表中查找。

  1. public class Main {
  2.      public static void main(String[] args) {
  3.          List<String> list = List.of(“A”, “B”, “C”);
  4.          // 下面的例子中即使对象的地址不同，但是属性值相同，因此在列表中能查到
  5.          System.out.println(list.contains(new String(“C”))); // true
  6.          System.out.println(list.indexOf(new String(“C”))); // 2
  7.      }
  8. }

在hash结构的表中使用

map是一种键值对的映射表，map使用一个很大的数组来存储value，然后通过key的hash值来查找value的索引

map其实可以看作一个数组，key的hashcode()值可以作为数组的索引，然后根据索引去查找value。

那究竟在什么地方使用equals()呢？

当我们输入key的时候，map需要将传入的key与当前数组中存入的key相比较。

  1. public class Main {
  2.      public static void main(String[] args) {
  3.          HashMap<String, String> map = new HashMap<>();
  4.          map.put(new String(“sss”),“hhh”);
  5.          map.put(new String(“sss”), “aaa”);
  6.          // map里只有一个数据，因为String重写了equals方法，所以key属性值一样的会被覆盖
  7.          System.out.println(map.size());
  8.          HashMap<Person, String> map1 = new HashMap<>();
  9.          map1.put(new Person(“xiao”,15), “ok”);
  10.          map1.put(new Person(“xiao”,15), “hao”);
  11.          // map1里有两个数据，明明key是一样的，却没有覆盖
  12.          System.out.println(map1.size());
  13.      }
  14. }
  15. class Person{
  16.      String name;
  17.      int age;
  18.      Person(String name, int age){
  19.          this.name = name;
  20.          this.age = age;
  21.      }
  22. }
  • 添加重复的键值对：由于Map将不同的对象视为不同的键，如果我们使用相同类型的不同对象作为键，即使它们的属性值相同，Map也会将它们视为不同的键，从而导致添加重复的键值对。
  • 无法查找键值对：由于Map将不同的对象视为不同的键，如果我们使用一个对象作为键添加了一个键值对，而后又使用另一个对象作为键查找该键值对，那么Map会认为这两个对象是不同的键，因此无法找到对应的键值对。

因此，我们需要正确重写equals()方法。

hashcode()方法

HashMap为什么能通过key直接计算出value存储的索引。相同的key对象（使用equals()判断时返回true）必须要计算出相同的索引，否则，相同的key每次取出的value就不一定对。

map是通过hashcode()去寻找value数组索引的，所以还需要为对象覆写hashcode()方法。

  1. public class Main {
  2.      public static void main(String[] args) {
  3.          HashMap<String, String> map = new HashMap<>();
  4.          map.put(new String(“sss”),“hhh”);
  5.          map.put(new String(“sss”), “aaa”);
  6.          // map里只有一个数据，因为String重写了equals方法和hashcode方法，所以key属性值一样的会被覆盖
  7.          System.out.println(map.size()); // 1
  8.          HashMap<Person, String> map1 = new HashMap<>();
  9.          Person p1 = new Person(“xiao”, 15);
  10.          map1.put(p1, “ok”);
  11.          Person p2 = new Person(“xiao”, 15);
  12.          map1.put(p2, “hao”);
  13.          // map现在也只有一个数据了，因为两个相同属性的对象被视作同一个
  14.          System.out.println(map1.size()); // 1
  15.      }
  16. }
  17. class Person{
  18.      String name;
  19.      int age;
  20.      Person(String name, int age){
  21.          this.name = name;
  22.          this.age = age;
  23.      }
  24.      // 覆写equals方法
  25.      @Override
  26.      public boolean equals(Object o) {
  27.          if (o instanceof Person p) {
  28.              return this.name.equals(p.name) && this.age == p.age;
  29.          }
  30.          return false;
  31.      }
  32.      // 覆写hashcode方法
  33.      @Override
  34.      public int hashCode() {
  35.          int h = 0;
  36.          h = 31 * h + name.hashCode();
  37.          h = 31 * h + age;
  38.          return h;
  39.      }
  40. }

map的put方法里是用到了hash值的，因此不正确重写hash值而正确重写equals方法是没用的。

小节

比较基本数据类型或对象地址用==, 比较对象地址使用Object的equals方法, 比较对象属性值使用覆写之后的equals().

对于list集合数据类型，本质是数组，当存储对象数据类型的值时，重写equals方法才能使用contains()等需要使用equals进行比较的方法。

对于hash table类型的数据，必须覆写equals与hashcode方法，才能正常工作。

到此这篇关于Java ==,equals()与hashcode()的使用的文章就介绍到这了,更多相关Java ==,equals()与hashcode()内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论