关于hashCode()和equals()，看这一篇就够了！

  我们经常被问到hashCode()方法和equals()方法的用法，以及什么时候需要重写这两个方法的类似问题，本文是我对这两个方法的一些理解。

一、equals()和"=="

  提到equals()和"=="，我们首先来理解一下它们的联系与区别。对于基本数据类型，==比较的是两边的值，对于引用类型，比较的是两个对象的地址是否相等。

   equals()用来比较两个对象是否相等，如果我们不重写equals方法的话，用的是Object类里的equals()，它也是用==来比较两边的地址的。

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

  String类就重写了equals()，用来比较字符串是否相等，而不是直接比较它们的地址。

public boolean equals(Object anObject) {
    if (this == anObject) {
        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;
        }
    }
    return false;
}

  可以看到重写后的方法首先判断两字符串的地址，然后再比较字符数组是否相同，因为String的底层就是就是一个用final修饰的字符数组嘛。

  这里的instance关键字用来判断方法传入的对象是否为String实例，如果不是也就没有必要进行下面的比较了。

二、equals()和hashCode()

  我们经常说，重写equals()要重写hashCode()，不过，只有在需要将对象存入散列表结构的时候，才需要这样做，例如HashMap，HashSet等。
  在这种情况下：

  1、equal()为true的两个对象的hashcode值一定相等

  2、hashcode值相同的两个对象不一定相等

  以HashSet为例，如果我们只重写equals()却不重写hashCode()，测试以下会是什么效果：

User类：

package test;
import java.util.Objects;


public class User {
    String name;
    int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

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

测试：

public class Test {
    public static void main(String[] args) {
        Set set = new HashSet();
        User user1 = new User("kun",18);
        User user2 = new User("kun",18);
        set.add(user1);
        set.add(user2);

        System.out.println("user1  hashcode:"+user1.hashCode());
        System.out.println("user2  hashcode:"+user2.hashCode());
        System.out.println("Set:"+set.toString());
        System.out.println(user1.equals(user2));
    }
}

结果：

  可以看到我们的set里存储了重复的对象，因为它们的hashcode值不同，set把它们看作不同的对象了，但是调用equals()返回的是true。

  下面我们重写一下hashCode()，就用下面比较简单的写法:

@Override
public int hashCode() {
    int nameCode = name.hashCode();
    return nameCode^age;
}

再次运行上面的测试代码：

可以看到，Set里是不允许有重复元素的，这才是我们想要的效果。