基本概念

要比拟两个对象是否相等时须要调用对象的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()办法 */@Overridepublic 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