java基础之hashCode

hashCode

       学习java的集合框架时，发现里面很多地方涉及到了hashCode的比较，于是决定先了解一下hashCode，再继续学习集合框架。

 

1.什么是hashCode？

    我们知道在java中，Object类是所有对象的父类，在Object类中有一个hashCode()方法：

public native int hashCode();

    可以看到这是一个本地的方法，它会返回一个int类型的数据，也就是说所有对象都会有一个属于自己的hashcode，大部分情况下hashcode和对象在内存中的存储地址相同，但不尽然，我们只需要知道hashcode是每个对象都有的一个属性，与内存中的存储地址相关联就可以了。

2.hashCode()方法的作用

    在讨论hashCode()方法之前，思考一个问题，我们所说的比较对象是否相同，比较的究竟是什么东西？

    之前在介绍数组的博客中，有描述过==和equals（）的区别：
        ==用于比较基本数据类型的值和引用类型变量指向的地址；
        equals（）用于比较引用类型变量指向的对象的值。

    再看下Object类中关于equals（）方法的源码：

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

    可以看到Object中的equals（）方法内部也是调用的==，也就是说比较的是对象在内存中的引用地址，同一个地址指向的就认为是同一个对象。

    hashCode（）作用的场景：

（1）. 但是在实际生活中，有时候对象在内存中存储的位置并不相同，但是我们通过他的属性来进行逻辑上的相同判断，这个时候我们就需要重写equals（）方法对对象进行判断，与此同时需要重写hashCode()方法；

（2）.在hashSet, hashMap和hashTable这种利用hash算法实现的集合中，底层都需要通过对象的hashCode()进行判断，这也是hashCode()方法主要发挥作用的地方。

3.为什么equals（）和hashCode()总要联系在一起？

     相信大家一定都听过这样的话，重写equals()方法，一定要记得同时重写hashCode()方法。有没有想过这是为什么呢？
     在上面说过，hashCode()方法作用的场景，我们这里就用hashMap来举个例子，说明一下为什么重写了equals()方法以后需要重写hashCode()方法。
我们写一个Student类，它有两个属性，名字和id，在里面我们重写了equals方法，我们认为当学生的姓名和id都一样时，这就是同一个学生。

    Student类：

package com.ljw.ColleactionAndMap;

/**
 * Created by liujiawei on 2018/6/27.
 */
public class Student {
    public String name;
    public String id;

    public Student(String name, String id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public boolean equals(Object obj) {
        return this.name.equals(((Student)obj).name) && this.id.equals(((Student)obj).id);
    }
}

测试类：

package com.ljw.ColleactionAndMap;

import java.util.HashMap;

/**
 * Created by liujiawei on 2018/6/27.
 */
public class TestHashMap {
    public static void main(String[] args) {
        HashMap<Student,String> m = new HashMap<>();
        Student jack = new Student("jack","12345");
        m.put(jack,"first");
        Student tom = new Student("jack","12345");
        System.out.println(jack.equals(tom));  //get true
        System.out.println(m.get(tom));
    }
}

对上面的测试类分析一下：
我们声明了一个HashMap用来存放学生信息，声明了一个jack，将jack放入了map中，同时我们声明了一个新同学tom，但是他的id和名字都和jack一样，想一下两行输出的内容会是什么？

运行结果：

    可以看到第一个输出的结果是true，因为我们重写了equals()方法，尽管tom和jack在内存中的位置不一样，但是返回的结果还是true，第二个输出的结果是null，这说明尽管这两个对象是相等的，但是hashmap并没有找到对应存放的数据，这是为什么呢？这就是因为我们在Student中只重写了equals()方法，没有重写hashCode()方法。我们看下hashmap中的get方法的源码：

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    Entry<K,V> entry = getEntry(key);

    return null == entry ? null : entry.getValue();
}

 

inal Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        return null;
    }

    int hash = (key == null) ? 0 : hash(key);
    for (Entry<K,V> e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

        我们可以看到hashmap中的get方法是通过在hash表通过hashcode找到对应的数据的，在上面的例子中，也就是说jack尽管和tom使用equals（）得到了true的结果，但是他们的hashcode确并不相同，所以第二个输出结果是null。

 

   事实上，如果两个对象equals()得到的结果是true，那么他们的hashcode也必须相等，这是基本原则，下面会介绍equals()方法和hashCode()方法的基本规则。

 

 

4.equals（）的通用规定摘自Effective Java）

• 自反性(reflexive)： 对于任何非null的引用值x, x.equals(x)必须返回true；
• 对称性(symmetric)： 对于任何非null的引用值x和y，当且仅当y.equals(x)返回true时，x.equals(y)必须返回true；
• 传递性(transitive)： 对于任何非null的引用值x、y和z,如果x.equals(y)返回true,并
• 且y.equals(z)也返回true,那么x.equals(2)也 必须返回true；
• 一致性; (consistent)：对于任何非null的引用值x和y，只要equals的比较操作在对象中所用的信息没有被修改，多次调用x.equals(y)就会一致地返回true,或者一致地返回false.

*对于任何非null的引用值x，x.equals(null)必 须返回false.

5.重写equals（）和hashCode()

• 重写equals()方法的通用方法（摘自Effective Java）：

（1）使用==操作符检查“参数是否为这个对象的引用”；

（2）使用instanceof操作符检查“参数是否是正确的类型”；

*新版已经通过比较class来做判断

（3）将参数转化为正确的类型；

（4）对于类中的每个关键域，检查参数的域是否和对象的域相匹配；

    如果按照上面的方法来进行重写equals（）方法，那么student中的标准写法应该是这样：

    @Override
    public boolean equals(Object obj) {
        if(this == obj){ //（1）判断引用
            return true;
        }
        if(obj instanceof Student){  //（2）判断类型
            Student anotherStudent = (Student) obj;  //（3）转换类型
            if(this.name.equals(anotherStudent.name) && this.id.equals(anotherStudent.id)) {  //（4） 比较关键域
                return true;
            }
        }
        return false;
    }
}

 

--修改自2018.0630

    @Override
    public boolean equals(Object obj) {
        if(this == obj){ //（1）判断引用
            return true;
        }
//        if(obj instanceof Student){  //（2）判断类型
        if(obj != null && obj.getClass() == Student.class){
            Student anotherStudent = (Student) obj;  //（3）转换类型
            if(this.name.equals(anotherStudent.name) && this.id.equals(anotherStudent.id)) {  //（4） 比较关键域
                return true;
            }
        }
        return false;
    }
}

 

• 重写hashCode()的基本原则：

（1）当两个对象过equals()方法得到的结果为true时，这两个对象的hashcode应该相等；
（2）对象中用于equals()比较的属性，都应该用来计算hashcode值。
*附上String类重写equals()和hashCode()的源码作为参考：

 

 

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

    hashCode():

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

6.小结

    (1)每个对象都有hashcode，这个值可能重复；
  （2）通过equals（）方法得到true结果的，那么他们的hashcode也相同；
hashcode相同的，equals（）得到的不一定是true；

  （3）通过hashcode，减少equals判断的次数。如果是在set这种不能存放重复数据的容器中增加数据时，新增的数据如果通过equals（）方法和里面所有已存在的数据进行比较的话，数据量庞大的情况，非常耗费性能，但是hashcode（）的比较不存在这种问题，找出hashcode相同的数据，再使用equals（）进行对象内容的比较，相同就判断为重复数据，不相同就是新数据，通过这种方式，可以增加性能。

--补充(2018.06.30)：

hash表的存储示意图：

    在hash表中，hashcode没有冲突时，也就是一个hashcode上对应一个数据，这个时候效率最高，当hashcode发生冲突时，会用链表来对数据进行管理。

 

参考博客:https://www.cnblogs.com/dolphin0520/p/3681042.html