为什么重写equals还要重写hashcode呢？

首先说一下，我们在什么时候要重写equals和hashcode，当我们将在Map和Set集合存储对象时，存储对象要重写equals和hashcode。

我们用Map做例子，因为Set底层调用的是Map集合。

我们先定义一个User类，属性就是name和age，这个里面我们先不重写hashcode和equals方法

复制代码
private String name;

private Integer age;

public User() {
}

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

public String getName() {
    return name;
}

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

public Integer getAge() {
    return age;
}

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

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

}
复制代码
下面给出测试

复制代码
public class Test {
public static void main(String[] args) {
User user1 = new User(“dd”,12);
User user2 = new User(“dd”,12);

    System.out.println("user1的hash值为: " + user1.hashCode());
    System.out.println("user2的hash值为: " + user2.hashCode());
    
    Map<User,Integer> mp = new HashMap<>();
    mp.put(user1,1);
    mp.put(user2,2);
    System.out.println(mp.size());
}

}
复制代码

测试结果如下：

通过上面的测试案例，我们可以看到，两个我们认为相等的User对象，为什么能同时加入到Map集合中去呢？

有人会说，你没有重写equals方法，它调用的是父类Object的equals方法，因为它比较的是两个对象的源码，你重写以后只能有一个对象加入，下面是Object的equals方法源码

public boolean equals(Object obj) {
return (this == obj);
}
从源码可以看出，它确实比较的是两个对象的地址，如果地址相同返回true，否则返回false，上面的例子当我们new两个User时，他们的地址确实不相等，所以说，你这是没有重写equals方法导致的，那么我们用事实说话，下面我们在User类中加上equals方法，看看是不是和我们想要的结果是否一样，equals方法我们用红色字体标记

User类

复制代码
public class User {
private String name;

private Integer age;

public User() {
}

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

public String getName() {
    return name;
}

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

public Integer getAge() {
    return age;
}

public void setAge(Integer age) {
    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 Objects.equals(name, user.name) &&
            Objects.equals(age, user.age);
}

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

}
复制代码
，测试类：

复制代码
public class Test {
public static void main(String[] args) {
User user1 = new User(“dd”,12);
User user2 = new User(“dd”,12);

    System.out.println("user1对象和user2对象相等吗？ "+user1.equals(user2));

    Map<User,Integer> mp = new HashMap<>();
    mp.put(user1,1);
    mp.put(user2,2);
    System.out.println("map集合大小为:"+mp.size());


}

}
复制代码
结果如下：

从测试结果我们可以看出，调用equals方法返回时true啊！两个对象相同啊，为什么Map集合的大小还是2呢？

这就回到我们今天所要说的正题上，为什么重写equals还要重写hashcode?我们先打印下 上面例子的两个User对象hashcode：

从上图可以看出两个对象的hash值不相同，那么就说明hashcode也影响我们值是否相等的一个因素，不用说，直接上代码验证一下：

User类，重写hashcode方法：

复制代码
public class User {
private String name;

private Integer age;

public User() {
}

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

public String getName() {
    return name;
}

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

public Integer getAge() {
    return age;
}

public void setAge(Integer age) {
    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 Objects.equals(name, user.name) &&
            Objects.equals(age, user.age);
}

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

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

}
复制代码
测试类：

复制代码
public class Test {
public static void main(String[] args) {
User user1 = new User(“dd”,12);
User user2 = new User(“dd”,12);

    System.out.println("user1对象和user2对象相等吗？ "+user1.equals(user2));
    System.out.println("user1的hash值为: " + user1.hashCode());
    System.out.println("user2的hash值为: " + user2.hashCode());

    Map<User,Integer> mp = new HashMap<>();
    mp.put(user1,1);
    mp.put(user2,2);
    System.out.println("map集合大小为:"+mp.size());


}

}
复制代码
测试结果：

通过测试结果可以看出，这次map集合的大小是1，那就说明user1和user2是同一个对象，这就是我们为什么重写eqauls还要重写hashcode的原因，主要原因还是调用Map集合的put方法时，他不仅会判断两个对象值相等还会判断两个对象的hash是否相等，(这里的值是根据你重写equals判断语句决定的，你也可以根据名字name相等来断定两个对象是同一对象，这个根据具体需求决定)，如果只是单纯的重写equals方法，不重写hashcode方法，那么调用put方法时，hash值不相等，也认为是相同元素，这也就回答了今天的正题，下面附上put方法源码：

复制代码
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e;
K k;
//主要看这块
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//还有这部分
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}