重写equals()方法不重写hashCode()方法带来的问题

1.两个方法的来源

首先，equals()方法与hashCode()方法都来源于Object类

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

由源码可知，equals()方法默认是在比较两个对象的内存地址是否一致
hashCode()方法是本地方法。

一般情况下，我们都在用java里面默认的一些类，如String，这些类里面其实已经重写了equals()与hashCode()方法。下面列出了String类中重写的equals()方法，hashCode()方法可自行查看源码

 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;
    }

2.为什么需要重写

2.1为什么要重写equals方法

我们平时在新建一个类以后，默认是不会重写它的equals()方法与hashCode()方法的，因为用不到呀。如果实在要用，可能只会重写equals()方法，毕竟equals()方法我们平时接触的更多

假定我们现在有一个Person类，有name，age两个字段

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

我们new两个Person类的对象出来

        Person p1 = new Person("张三", 18);
        Person p2 = new Person("张三", 18);
        System.out.println(p1.equals(p2));

发现结果为false
因为此时在调用equals方法时，默认用的是Object类中的equals()方法，它比较的是两个对象的地址值
很明显，这不合理，这个时候我们就需要重写equals()方法，【idea使用alt+insert可以插入equals方法】

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

此时，再次比较p1与p2的值，发现结果为true
进行到这里时，我们发现没啥问题，那为什么要重写hashCode()方法呢

2.2为什么要重写hashCode方法

一般情况下，我们使用的数据结构都是数组、list等等
但存在一个问题，当我想查询数组里面是否存在元素x时（注意，不是访问数组的某个下标），此时只能挨个遍历数组元素，时间复杂度为O(n)。
怎么解决这个问题，查询元素x的时间复杂度能不能为O(1)？

2.2.1散列表知识

数据结构中有一种结构为散列（hash）表，为了简单起见，我将这里的散列表的组成形式设计为数组+链表的形式

首先，在查询某个元素x时，首先，通过hashCode方法得到其hash值，再通过hash值计算出其在散列表中的数组下标位置，如果该位置上没有元素（比如下标2,3）,则说明散列表中没有元素x，如果该位置上有元素（如下标1），则x会依次与a1,d1进行比较，若不相等，则找不到，若其中一个相等，则说明散列表中有元素x。
这样一个，查询元素x的时间复杂度是不是就是O(1)了，当然，如果散列函数设计不当，所有的元素都集中到同一个数组下标位置了，就会造成问题（这是后话）。

2.2.2重写hashCode()方法

在java中，比较常用的hashMap、hashSet就是采用上述思想
为什么要重写hashCode()方法
以hashSet为例，先看下面这段代码，Person只重写了equals方法，未重写hashCode方法。

 		HashSet<Person> set = new HashSet<>();

        Person p1 = new Person("张三", 18);
        Person p2 = new Person("张三", 18);
        set.add(p1);
        set.add(p2);

        System.out.println(set.size());

此时set的大小为2，明显不合理，因为set存放的元素不能重复。
为什么会这样？？
因为hashset在将p2进行存放时，计算出p2的hash值与p1不一样（采用的是Object默认的hashCode方法计算得出），故它们在数组中的下标位置可能也不一样，java会将其当做两个不同的对象进行处理，故p2能成功的存放到hashset中去
解决方法：在Person类中重写hashCode方法【idea快捷键：alt+insert】

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

此时，set的大小为1
这样一来，在存放p2时，先通过p2的hash值计算出数组下标，此时发现该位置上已经有元素了（数组下标相同的元素会放在同一个链表中），接着，会去遍历这个链表，比较他们的name和age值是否和p2的name、age值相同（通过equals方法），如果相同，就不会将p2存进去，所以此时set的大小为1.
当然如果不相同，就会将p2存进去。

综上所述：
hashMap、HashSet在比较元素时，会先通过hashCode进行比较，相同的情况下再通过equals进行比较。
所以：equals相等的两个对象，hashCode一定相等
hashCode相等的两个对象，equals不一定相等（比如散列冲突的情况）

重写了equals方法，不重写hashCode方法时，可能会出现equals方法返回为true，而hashCode方法却返回false。这样的一个后果会导致在hashmap、hashSet等类中存储多个一模一样的对象，这与java的思想不符（因为：hashmap只能有唯一的key，hashSet只能有唯一的对象）