JAVA中的equals与hashCode

一、”==“ 比较相等

== 判断相等的运算符，他有两种使用方式：
1、== 用来判断基本数据类型 
在JAVA中 == 对于基本数据类型byte short int long char double float boolean的判断是基于数值的。

public static void compare(){
    int a=300;
    int b=300;
    System.out.println(a==b);
}

a,b都是方法中的局部变量,他们的生命周期就是该方法的入栈到出栈，300会直接存在虚拟机栈中，变量a的引用指向该栈中的300，变量b的引用也指向300，所以 a==b 比较的就是他们指向的值

2、== 用来判断引用数据类型 
在JAVA中 == 如果用来判断引用数据类型，比较的是他们的地址值

public static void compare(){
   Object obj1=new Object();
   Object obj2=new Object();
   System.out.println(obj1==obj2);//false
}

在java使用new，JVM会在堆内存中开辟一块新的地址空间，所以变量obj1的引用指向堆内存中的一块地址，变量obj2的引用指向堆内存中另外一个地址 ，所以 obj1==obj2 实质就是比较两个引用是否指向同一个内存地址

二、equals 方法

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

由此可见Object中提供的equals方法也是”==“比较的方法，但equals方法是提供给引用类型使用的，他希望我们的比较运算，既要关注地址更要注重里面的内容；

public static void compare(){
   String str="ABC";
   String str2=new String("ABC");
   System.out.println(str==str2);//false
   System.out.println(str.equals(str2));//true
}

字符串的equals方法为什么返回true

//String 重写的equals
public boolean equals(Object anObject) {
    //先比较地址
    if (this == anObject) {
        return true;
    }
    //看看是否是String类型
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                //一个字符一个字符的比较(String的数据结构就是 char[] value)
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

String 重写了父类Object中的equals方法，我们可以发现重写后equals 关注的是内容是否相等，在实际工作中我们自定义对象的场景较多，如果要判断两个对象是否相等，要根据自己的需求决定是否重写equals方法：

1. 只需要关注两个对象的地址是否相同，那就不用重写Object中的equals方法
2. 需要关注对象中每个属性的值是否相等，那就需要重写Object中的equals方法

三、hashcode

public native int hashCode();

在java中hashcode主要用于确定数据在hash表(HashSet、HashMap...)中的存储位置，java对hashcode方法的值是有一定要求的。

hashcode方法的规则：

1. 在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数
2. 如果两个对象equals方法比较相等，那么它们的hashCode值一定要相同；
3. 如果两个对象的hashCode相同，它们的equals方法比较并不一定相等；

每个对象的hashcode值在new的 时候会生成在对象头中；

为什么重写equals方法后要重写hashcode：

class User{
    private Integer id;
    private String name;
    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id) && Objects.equals(name, user.name);
    }
   /*    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }*/
}

User user1 =new User(1,"ABC");
User user2 =new User(1,"ABC");
System.out.println(user1.equals(user2));//true
System.out.println(user1.hashCode()==user2.hashCode());//false

由结果我们可知当我们重写equals后两个内容一样的对象，equals结果是true，而在不重写hashcode的情况下，他们的hashcode值不相等，显然违反了“如果两个对象equals方法比较相等，那么它们的hashCode值一定要相同” 原则。