Java中的==、equals和hashCode

==

== 是一个比较运算符，既可以判断基本类型，又可以判断引用类型

• 如果判断基本类型，判断的是值是否相等

int i = 10;
double d = 10.0;
System.out.println(i == d);	//true，精度小的类型自动转换为精度大的数据类型，值是一样的

//只要有基本数据类型，判断的是值是否相同
Integer a = 127;
int b = 127;
System.out.println(a == b);	//true

//这里主要是看范围-128~127就是直接返回，否则就new Integer(xx)
Integer e = 128;    
Integer f = 128;
System.out.println(e == f);	//false

• 如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象

String a = new String("123");
String b = a;
String c = new String("123");
String d = "123";
String e = "123";
System.out.println(a == b); //true，b指向了a的地址
System.out.println(a == c); //false，只要是new出来的对象都会在堆里新开辟一个空间
System.out.println(c == d); //false，一个在堆里，一个在常量池中，存放的位置不一样，地址也就不一样
System.out.println(d == e); //true，由于已经在常量池中存在了“123”常量，所以不会新开辟空间，直接引用原来的地址

String类在进行字符串拼接的时候，如果是变量连接，底层会用StringBuilder来接收，然后进行append，最后调用toString方法，返回的是一个拼接好的新字符串。如果是字符串常量连接，编译器会做优化，直接返回拼接好的字符串

String a = "hello";
String b = "world";
String c = a + b;
String d = "helloworld";
String e = "hello" + "world";
System.out.println(c == d); //false
System.out.println(d == e); //true
System.out.println(c == e); //false

上述a+b的执行过程：

用javac编译的class文件，可以看出变量e是已经是拼接后的结果

equals

equals是Object类中的方法，只能判断引用类型。默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。比如Integer，String。

Object的equals方法默认就是比较对象地址是否相同，也就是判断两个对象是不是同一个对象

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

String类的 equals方法，把Object的equals方法重写了，变成了比较两个字符串值是否相同

public boolean equals(Object anObject) {
    if (this == anObject) {//如果是同一个对象，返回true
        return true;
    }
    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) {//然后一个一个的比较字符
                if (v1[i] != v2[i])
                     return false;
                i++;
            }
            return true;//如果两个字符串的所有字符都相等，则返回true
        }
    }
    return false;//如果比较的不是字符串或者字符串长度不相等，则直接返回false
}

从源码可以看到 Integer 也重写了Object的equals方法，变成了判断两个值是否相同

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

所以，如果我们想比较两个对象是否相等，要重写equals方法

public class Person {
    public String name;
}

Person person = new Person();
person.name = "小明";
Person person2 = new Person();
person2.name = "小明";
System.out.println(person == person2);  //false
System.out.println(person.name.equals(person2.name)); //true,因为String重写了Object的equals方法，所以比较的是内容是否相等
System.out.println(person.equals(person2)); //false，因为Person类未重写Object的equals方法，所以比较的是地址

hashCode

Object类的hashCode是一个native方法，不同的对象的hashCode一定是不同的。哈希值一般是通过将该对象的内部地址转换成一个整数来实现的， 不能完全将哈希值等价于地址。

我们都知道可以用HashSet用来存储不同的对象，HashSet中没有重复的元素，下面我们来看一个例子

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name);
    }

    public static void main(String[] args) {
        Person person1 = new Person("张三");
        Person person2 = new Person("张三");
        HashSet set = new HashSet();
        set.add(person1);
        set.add(person2);
        System.out.println("set= " + set);
    }

}

测试结果：

set= [Person{name='张三'}, Person{name='张三'}]

上面的Person类中只重写了equals方法，HashSet中存入了两个name值相同的Person对象，我们期待name值相同，就认定是相同的对象，那为什么用HashSet存储没有出现我们期待的结果呢？

原因在于HashSet是先根据对象的hashcode生成存储数据表table的索引，看该索引位置上有没有值，没有就直接加入，有就调用对象的equals方法进行比较，如果比较结果相同，就插入不了，如果不相同，就添加到最后。

看一下HashMap源码，因为HashSet底层是HashMap，先比较的还是hash值，此hash值不是hashcode直接生成的，而是进一步作了处理，然后判断是不是同一个对象，不是就调用equals方法比较。

根据HashSet对对象的判定方法，我们需要重写hashCode和equals方法，以达到对对象内容的判定。

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    public static void main(String[] args) {
        Person person1 = new Person("张三");
        Person person2 = new Person("张三");
        HashSet set = new HashSet();
        set.add(person1);
        set.add(person2);
        System.out.println("set= " + set);
    }

}

测试结果：

set= [Person{name='张三'}]

结论：

对于equals()相等的两个对象，其hashCode()返回的值一定相等。