为什么重写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 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 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 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[] tab; Node 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 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)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;
    }
             

 

转载于:https://www.cnblogs.com/du001011/p/11343326.html