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

要比拟两个对象是否相等时须要调用对象的equals() 办法:
- 判断对象援用所指向的对象地址是否相等
对象地址相等时, 那么对象相干的数据也相等, 包含:
- 对象句柄
- 对象头
- 对象实例数据
- 对象类型数据
能够通过比拟对象的地址来判断对象是否相等

Object 源码
对象在不重写的状况下应用的是 Object 中的equals() 办法和hashCode() 办法
- equals(): 判断的是两个对象的援用是否指向同一个对象
- hashCode(): 依据对象地址生成一个整数数值
Object的 hashCode() 办法修饰符为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);
}

如果没有重写 Object 的hashCode() 办法, 会呈现:

[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** 存储的时候是没有法则可循的

基本概念

Object 源码

重写 equals

重写 hashCode