为什么重写EQUALS时必须重写HASHCODE方法

一 ：string类型的==和equals的区别：

结论："=="是判断两个字符串的内存地址是否相等，equals是比较两个字符串的值是否相等。       

String s1 = new String("java");
String s2 = new String("java");

System.out.println(s1==s2); //false
System.out.println(s1.equals(s2)); //true

在Java中，equals和hashCode方法是Object中提供的两个方法，string类型重写了equals()方法和hashCod()方法，源码如下：

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

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

二：对象equals 和hashcode的关系

结论：当对象的equals()方法被重写时，通常有必要重写 hashCode() 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。如下：

1. 两个对象相等，hashcode一定相等
2. 两个对象不等，hashcode不一定不等
3. hashcode相等，两个对象不一定相等
4. hashcode不等，两个对象一定不等

hashcode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进行判断是否相同的。这样如果我们对一个对象重写了euqals，意思是只要对象的成员变量值都相等那么euqals就等于true，但 不重写hashcode，那么我们再new一个新的对象，当原对象.equals（新对象）等于true时，两者的hashcode却是不一样的，由此将产生了理解的不一致。

三 ：使用HashMap，如果key是自定义的类，就必须重写hashcode()和equals()

　　  A.当put元素时：

              1.首先根据put元素的key获取hashcode,然后根据hashcode算出数组的下标位置,如果下标位置没有元素，直接放入元素即可。
              2.如果该下标位置有元素（即根据put元素的key算出的hashcode一样即重复了），则需要已有元素和put元素的key对象比较equals方法，如果equals不一样，则说明可以放入进map中。这里由于hashcode一样，所以得出的数组下标位置相同。所以会在该  数组位置创建一个链表，后put进入的元素到放链表头，原来的元素向后移动。

         B.当get元素时：

             根据元素的key获取hashcode，然后根据hashcode获取数组下标位置，如果只有一个元素则直接取出。如果该位置一个链表，则需要调用equals方法遍历链表中的所有元素与当前的元素比较,得到真正想要的对象。

       C. 采用hashcode的好处：

          如果我们不使用hashcode，直接使用equals比较，那么我们有10w个元素，put值或者get值时要比较10w次，如果先通过hashcode判断后，我们的效率就会提高很多。

          我们可以对比实际生活中，如果有一栋教学楼，一楼是1年级，二楼是2年级，以此类推，六楼是6年级，这时我们需要找5年级2班在哪间教室，通过hashcode直接定位到5楼，然后在5楼一间间找就行了，这样避免从一楼一间一间查看。

       

 四.：代码展示，为什么重写equals时必须重写hashCode方法

         我们以一个student 学生类来测试重写equals()和重写hashcode()后，map的get()方法返回值结果，让大家清晰了解为什么重写equals时必须重写hashCode方法

          

public class Student {
    private String name; //姓名
    private String sex;  //性别
    private String idCard;//身份证号
    Student(String name,String sex,String idCard){
        this.name = name;
        this.sex = sex;
        this.idCard = idCard;
    }
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getIdCard() {
        return idCard;
    }
    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }
     
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        if(obj == null){
            return false;
        }
        Student obj1 = (Student)obj;
        if(this.name.equals(obj1.getName()) && this.idCard.equals(obj1.getIdCard())){
            return true;
        }
        return false;
    }
     
    //@Override
    public int hashCode() {
        // TODO Auto-generated method stub
        String s= this.name + this.idCard;
        return s.hashCode();
    }
     
}


public static void main(String[] args) throws Exception {
        Map<Student,Student> map = new HashMap<Student,Student>();
        Student s1 = new Student("haly","male","110200");
        Student s2 = new Student("haly","female","110200");
        map.put(s1, s1);
   
        System.out.println(map.get(s2));
         
        // 当没有重写equals方法和hashcode方法，打印出null
        // 当重写equals方法，不重写hashcode方法时，打印出null
        // 当重写equals方法,并且重写hashcode方法时,打印出[email protected]
         
    }