关于java:内存泄漏避雷你真的了解重写equals和hashcode方法的原因吗

44次阅读

共计 4672 个字符,预计需要花费 12 分钟才能阅读完成。

基本概念

  • 要比拟两个对象是否相等时须要调用对象的equals() 办法:

    • 判断对象援用所指向的对象地址是否相等
  • 对象地址相等时, 那么对象相干的数据也相等, 包含:

    • 对象句柄
    • 对象头
    • 对象实例数据
    • 对象类型数据
  • 能够通过比拟对象的地址来判断对象是否相等

    Object 源码

  • 对象在不重写的状况下应用的是 Object 中的equals() 办法和hashCode() 办法

    • equals(): 判断的是两个对象的援用是否指向同一个对象
    • hashCode(): 依据对象地址生成一个整数数值
  • ObjecthashCode() 办法修饰符为native: 表明该办法是由操作系统实现. Java 调用操作系统底层代码获取Hash

    public native int hashCode();

    重写 equals

  • 重写 equals()办法的场景:

    • 假如当初有很多学生对象
    • 默认状况下, 要判断多个学生对象是否相等, 须要依据地址判断:

      • 若对象地址相等, 那么对象实例的数据肯定是一样的
    • 判断相等的要求:

      • 当学生的姓名, 年龄, 性别相等时, 认为对象是相等的,
      • 不肯定须要对象的地址完全相同
  • 依据需要重写 equals()办法:

    public class Student {
      /** 姓名 */
      private String name;
      /** 性别 */
      private String sex;
      /** 年龄 */
      private String age;
      /** 体重 */
      private float weight;
      /** 地址 */
      private String addr;
    
      /*
       * 重写 equals()办法
       */
      @Override
      public boolean equals(Object obj) {
          // instanceof 曾经解决了 obj == null 的状况
            if (! (Object instanceof Student)) {return false;}
            Student stuObj = (Student) obj;
            // 地址相等
            if (this == stuObj) {return true;}
            // 如果对象的姓名, 年龄, 性别相等. 则两个对象相等
            if (stuObj.name.equals(this.name) && stuObj.sex.equals(this.sex) && stuObj.age.equals(this.age)) {return true;} else {return false;}
       }
    
       public String getName() {return name;}
       public void setName(String name) {this.name = name;}
       public String getSex() {return sex;}
       public void setSex(String sex) {this.sex = sex;}
        public String getAge() {return age;}
       public void setAge(String age) {this.age = age;}
       public String getWeight() {return weight;}
       public void setName(String weight) {this.weight = weight;}
       public String getAddr() {return addr;}
       public void setAddr(String addr) {this.addr = addr;}
    }
  • 示例:

    public static void main(String[] args) {Student s1 = new Student();
      s1.setAddr("earth");
      s1.setAge("20");
      s1.setName("Tom");
      s1.setSex("Male");
      s1.setWeight(60f);
    
      Student s2 = new Student();
      s2.setAddr("Mars");
      s2.setAge("20");
      s2.setName("Tom");
      s2.setSex("Male");
      s2.setWeight(70f);
    
      if (s1.equals(s2)) {System.out.println("s1 == s2");
      } else {System.out.println("s1 != s2");
      }
    }
  • 重写了equals() 办法后, 这里会输入 [s1==s2]
  • 如果没有重写 equals() 办法, 那么必定会输入 [s1!=s2]

    重写 hashCode

  • 依据重写 equals 的办法, 上述 s1 和 s2 认为是相等的
  • Object 中的 hashCode()办法:

    • equals() 办法没被批改的前提下, 屡次调用同一个对象的hashCode() 办法返回的值必须是雷同的负数
    • 如果两个对象相互 equals(), 那么这两个对象的hashcode 值必须相等
    • 为不同的对象生成不同的 hashcode 能够晋升 Hash 表的性能
  • 重写 hashCode()办法:

    public class Student {
    /* 姓名 /
    private String name;
    /* 性别 /
    private String sex;
    /* 年龄 /
    private String age;
    /* 体重 /
    private float weight;
    /* 地址 /
    private String addr;

    /*

    • 重写 hashCode()办法
      */

    @Override
    public int hashCode() {

       int result = name.hashCode();
       result = 17 * result + sex.hashCode();
       result = 17 * result + age.hashCode();
       return result;

    }

    /*

    * 重写 equals()办法
    */

    @Override
    public boolean equals(Object obj) {

        // instanceof 曾经解决了 obj == null 的状况
        if (! (Object instanceof Student)) {return false;}
        Student stuObj = (Student) obj;
        // 地址相等
        if (this == stuObj) {return true;}
        // 如果对象的姓名, 年龄, 性别相等. 则两个对象相等
        if (stuObj.name.equals(this.name) && stuObj.sex.equals(this.sex) && stuObj.age.equals(this.age)) {return true;} else {return false;}

    }

    public String getName() {

        return name;

    }
    public void setName(String name) {

        this.name = name;

    }
    public String getSex() {

        return sex;

    }
    public void setSex(String sex) {

        this.sex = sex;

    }
    public String getAge() {

        return age;

    }
    public void setAge(String age) {

        this.age = age;

    }
    public String getWeight() {

        return weight;

    }
    public void setName(String weight) {

        this.weight = weight;

    }
    public String getAddr() {

        return addr;

    }
    public void setAddr(String addr) {

        this.addr = addr;

    }
    }

  • 在两个对象相等的状况下, 别离放入 Map 和 Set 中:

    public static void main(String[] args) {Student s1 = new Student();
      s1.setAddr("earth");
      s1.setAge("20");
      s1.setName("Tom");
      s1.setSex("Male");
      s1.setWeight(60f);
    
      Student s2 = new Student();
      s2.setAddr("Mars");
      s2.setAge("20");
      s2.setName("Tom");
      s2.setSex("Male");
      s2.setWeight(70f);
    
      if (s1.equals(s2)) {System.out.println("s1 == s2");
      } else {System.out.println("s1 != s2");
      }
      
      Set set = new HashSet();
      set.add(s1);
      set.add(s2);
      System.out.println(Set);
    }
  • 如果没有重写 ObjecthashCode() 办法, 会呈现:

    [com.oxford.Student@7852e922, com.oxford.Student@4e25154f]
  • 这是不合乎预期的, 因为 Set 容器有去重的个性. 相等的元素不会反复显示. 这就波及到 Set 的底层实现了
  • HashSet 底层实现:

    • HashSet底层是通过 HashMap 实现的
    • 比拟 Set 容器内元素是否相等是通过比拟对象的 hashcode 来判断是否相等的
  • hashCode()的写法:

    • 首先整顿出判断对象相等的属性
    • 而后去一个尽可能小的正整数, 避免最终后果超出整型 int 的取数范畴
    • 而后计算[正整数 * 属性的 hashCode + 其余某个属性的 hashCode]
    • 反复步骤
    /*
     * 重写 hashCode()办法
     */
    @Override
    public int hashCode() {int result = name.hashCode();
      result = 17 * result + sex.hashCode();
      result = 17 * result + age.hashCode();
      return result;
# 原理剖析
- 因为没有重写父类的 **Object** 的 **hashCode()** 办法, 所以 **Object** 的 **hashCode()** 办法会依据两个对象的地址生成响应的 **hashcode**
- 因为两个对象别离是实体类创立的不同的实例, 所以地址必定是不一样的, 那么 **hashcode** 值也是不一样的
- **Set 区别对象是不是惟一的规范:**
  - 两个对象的 **hashcode** 值是否一样
  - 而后再断定两个对象是否 **equals** 
- **Map 区别对象是不是惟一的规范:**
  - 先依据 **Key** 值的 **hashcode** 调配来获取保留数组下标
  - 而后再依据 **eaquals** 辨别是否是惟一值 
# HashMap
### HashMap 组成构造
- **HashMap:** 是由 ** 数组 ** 和 ** 链表 ** 组成的
### HashMap 的存储
- **HashMap 的存储:**
  - 一个对象存储到 **HashMap** 中的地位是由 **key** 的 **hashcode** 值决定的 
  - **HashMap 查找 key:**
    - 查找 **key** 时 **,hashMap** 会先依据 **key** 值的 **hashcode** 通过取余算法定位所在数组的地位
    - 而后依据 **key** 的 **equals** 办法匹配雷同的 **key** 值获取相应的对象 
- ** 存值规定:**
  - 将 **Key** 的 **hashcode** 与 **HashMap** 的容量, 进行 ** 取余 ** 运算得出该 **Key** 存储在数组所在位置的下标
- **HashMap 查找 key:**
  - 失去 **key** 在数组中的地位
  - 匹配失去对应 **key** 值对象
  - 而后将上述多个对象依据 **key.equals()** 来匹配获取对应的 key 的数据对象
- **HashMap 中的 hashCode:** 
  - 如果没有 **hashcode** 就意味着 **HashMap** 存储的时候是没有法则可循的

正文完
 0