重写equal方法后需要重写hashcode方法

落日映苍穹つ 2024-03-30 16:07 45阅读 0赞

### hashCode1 和 equals2 协同判断两个对象是否相同 ###

*  equals 方法和 hashCode 方法是 Object 类中的两个基础方法当我们对比两个对象是否相等时，我们就可以先使用 hashCode 进行比较，如果比较的结果是 true，那么就可以使用 equals 再次确认两个对象是否相等，如果比较的结果是 true，那么这两个对象就是相等的，否则其他情况就认为两个对象不相等。这样就大大的提升了对象比较的效率，这也是为什么 Java 设计使用 hashCode 和 equals 协同的方式，来确认两个对象是否相等的原因。
 *  那为什么不直接使用 hashCode 就确定两个对象是否相等呢？  
    这是因为 如果两个对象相等，则hashcode一定也是相同的；两个对象有相同的hashcode值，它们并不一定是相等的。

### equals方法说明 ###

*  Object 类中的 equals 方法用于检测一个对象是否等于另外一个对象。在 Object 类中，这个方法将判断两个对象是否***具有相同的引用***。如果两个对象具有相同的引用，它们一定是相等的。

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

/**
     *
     */
    class User {
        
        private String name;
        private Integer age;
     
        public User(String name, Integer age) {
        
            this.name = name;
            this.age = age;
        }
     
        public String getName() {
        
            return name;
        }
     
        public void setName(String name) {
        
            this.name = name;
        }
     
        public Integer getAge() {
        
            return age;
        }
     
        public void setAge(Integer age) {
        
            this.age = age;
        }
    }
     
    public class EqualsMethodTest {
        
        public static void main(String[] args) {
        
            User u1 = new User("张起灵", 18);
            User u2 = new User("张起灵", 18);
            System.out.println(u1.equals(u2));
        }
    }
    输出为 false

*  通常情况下，我们要判断两个对象是否相等，一定要重写 equals 方法.
 *  8种数据类型的包装类、String这些类都重写了equals方法的。

### hashCode 方法说明 ###

*  hashCode 翻译为中文是散列码，它是由对象推导出的一个整型值，并且这个值为任意整数，包括正数或负数。需要注意的是：散列码是没有规律的。如果 x 和 y 是两个不同的对象，x.hashCode() 与 y.hashCode() 基本上不会相同（有可能相同）；但如果 a 和 b 相等，则 a.hashCode() 一定等于 b.hashCode()。  
    源码

public native int hashCode();

*  在不重写hashcode方法时的源码

/**
     *
     */
    class People {
        
        private String name;
        private Integer age;
     
        public People(String name, Integer age) {
        
            this.name = name;
            this.age = age;
        }
     
        public String getName() {
        
            return name;
        }
     
        public void setName(String name) {
        
            this.name = name;
        }
     
        public Integer getAge() {
        
            return age;
        }
     
        public void setAge(Integer age) {
        
            this.age = age;
        }
    }
     
    public class HashCodeMethodTest {
        
        public static void main(String[] args) {
        
            People p1 = new People("张起灵", 18);
            People p2 = new People("张起灵", 18);
            System.out.println(p1.hashCode());
            System.out.println(p2.hashCode());
        }
    }
    
    
    输出
    19291231313
    20232252525

\-重写hashCode之后，两个对象相同，它们的hashCode值相同。

### 为什么需要equal和hashcode都需要同时重写？ ###

#### 这是要保证宏观条件上的两个属性值相同的两个对象的进行比较时为true ####

*  1、Set 集合是用来保存不同对象的，相同的对象就会被 Set 合并，最终留下一份独一无二的数据。

import java.util.HashSet;
    import java.util.Set;
    
    /**
    *
    */
    public class EqualsHashCodeTest {
        
       public static void main(String[] args) {
        
           Set<String> set = new HashSet<>();
           set.add("Java");
           set.add("Java");
           set.add("SpringBoot");
           set.add("SpringBoot");
           set.add("SpringBoot");
           set.add("Redis");
           System.out.println("set集合的长度为：" + set.size());
           set.forEach(System.out::println);
       }
    }
    
    
    输出结果为 ： 
     set集合的长度为：3
     java 
     SpringBoot
     Redis

*  编写一个类，重写equals(),不重写hashcode()

import java.util.HashSet;
    import java.util.Objects;
    import java.util.Set;
     
    /**
     *
     */
    class Student {
        
        private String name;
        private Integer age;
     
        public Student(String name, Integer age) {
        
            this.name = name;
            this.age = age;
        }
     
        public String getName() {
        
            return name;
        }
     
        public void setName(String name) {
        
            this.name = name;
        }
     
        public Integer getAge() {
        
            return age;
        }
     
        public void setAge(Integer age) {
        
            this.age = age;
        }
     
        @Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return Objects.equals(name, student.name) && Objects.equals(age, student.age);
        }
     
    //    @Override
    //    public int hashCode() {
        
    //        return Objects.hash(name, age);
    //    }
     
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
     
    public class EqualsHashCodeTest {
        
        public static void main(String[] args) {
        
            Set<Student> set = new HashSet<>();
            set.add(new Student("张起灵", 18));
            set.add(new Student("张起灵", 18));
            System.out.println("set集合的长度为：" + set.size());
            set.forEach(System.out::println);
        }
    }
    
    
    输出结果 
     set集合的长度为: 2
     Student(name = 张起灵, age = 18)
     Student(name = 张起灵, age = 18)
    
    - 即使两个对象是相等的，Set 集合竟然没有将二者进行去重与合并。这就是重写了 equals 方法，但没有重写 hashCode 方法的问题所在。
    
    解决上述问题，自然就是在重写equals的同时一定要重写hashCode！！！

*  重写hashcode方法

import java.util.HashSet;
    import java.util.Objects;
    import java.util.Set;
     
    /**
     *
     */
    class Student {
        
        private String name;
        private Integer age;
     
        public Student(String name, Integer age) {
        
            this.name = name;
            this.age = age;
        }
     
        public String getName() {
        
            return name;
        }
     
        public void setName(String name) {
        
            this.name = name;
        }
     
        public Integer getAge() {
        
            return age;
        }
     
        public void setAge(Integer age) {
        
            this.age = age;
        }
     
        @Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return Objects.equals(name, student.name) && Objects.equals(age, student.age);
        }
     
        @Override
        public int hashCode() {
        
            return Objects.hash(name, age);
        }
     
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
     
    public class EqualsHashCodeTest {
        
        public static void main(String[] args) {
        
            Set<Student> set = new HashSet<>();
            set.add(new Student("张起灵", 18));
            set.add(new Student("张起灵", 18));
            System.out.println("set集合的长度为：" + set.size());
            set.forEach(System.out::println);
        }
    }
    
    
    输出结果：
    set集合的长度为：1
    Student(name =张起灵,age =18)

*  但是，如果在重写 equals 方法时，也重写了 hashCode 方法，那么在执行判断时会去执行重写的 hashCode 方法，此时对比的是两个对象的所有属性的 hashCode 是否相同，于是调用 hashCode 返回的结果就是 true，再去调用 equals 方法，发现两个对象确实是相等的，于是就返回 true 了，因此 Set 集合就不会存储两个一模一样的数据了，于是整个程序的执行就正常了。

#### 1、对于基本类型和引用类型 == 的作用效果是不同的，如下所示： ####

*  基本类型：比较的是值是否相同；
 *  引用类型：比较的是引用是否相同；

#### 2、重写引用类型的equals方法是为了将引用比较改成值的比较 ####

#### 3、两个对象的 hashCode() 相同，则 equals() 也一定为 true，这是不对的。 ####

String str1 = "通话";
    String str2 = "重地";
    System. out. println(String. format("str1：%d | str2：%d",  str1. hashCode(),str2. hashCode()));
    System. out. println(str1. equals(str2));

执行结果：

str1：1179395 | str2：1179395
     
    false