java重写hashCode和equals方法的坑点及原理剖析

引言

今天时间比较零散，先把这几个遗留的草稿做了，希望能带给大家一些不一样的讲解。

原生equals方法介绍

首先，这个equals()方法指的是Object中的方法，而不是String类中的方法。所以比较对象相等时既可以用obj.equals() 也可以用 == 。但是，在比较字符串是否相等时必须用str.equals()，因为字符串的equals方法实现跟Object的是完全不同的！String 的equals方法也是重写了Object 的方法来的。

Object方法中的equals

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

String中的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;
    }

由代码可以知道， 比较对象使用的是== ，即对象指向的地址。比较字符串则比较的内容。来看示例

package JAVA原理及应用.HashCode和equals;

/**
 * Created by Administrator on 2019-7-19 0019.
 */
public class TestHashCode {
	public static void main(String [] args){
        String str1 =new String( "12345");
        String st2 = new String("12345");
        System.out.println(str1.equals(st2));
        //true 调用的是String的equals方法，所以比较的是字符串的值
        System.out.println(str1==st2);
        //false 比较的是两个对象的地址
        Object obj1 =new String( "123456");
        Object obj2 = new String("123456");
        System.out.println(obj1.equals(obj2));
        //true 看似调用的是Object的equals方法，但是其实调用的是子类的实现equals 所以仍是true
        System.out.println(obj1==obj2);
        //false 比较的是两个对象的引用
	}
}

有个问题我们要提一下，为什么String类中没有声明继承自Object，但是我们知道是他的子类呢？这是因为在JDK规范中，

如果在类的声明中未使用extends关键字指明其父类，则默认的父类为Object类，即Object是所有类的父类。

重写equals方法

假设我们有一个场景，并且这个场景很普遍， 就是我要比较两个对象相不相同，这个要怎么比较呢？那当然不能直接用equals方法了，因为在没有重写equals方法之前，这两个对象的equals会指向Object的方法，所以必然是false。所以这时候就要重写equals方法了。请看示例：

package JAVA原理及应用.HashCode和equals;

/**
 * Created by haozhixin on 2019/9/10.
 */
public class TestOverWriteEquals {
    public String id;
    public String name;
    public TestOverWriteEquals(String id,String name){
        this.id = id;
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public String getId() {
        return id;
    }
    @Override
    public boolean equals(Object obj){
        if(obj instanceof TestOverWriteEquals){
            TestOverWriteEquals testOverWriteEquals = (TestOverWriteEquals) obj;
            if(id==null||name==null){//防止因equals左边的类对象是null产生空指针异常
                return false;
            }
            return id.equals(testOverWriteEquals.getId())&&name.equals(testOverWriteEquals.getName());
        }
        return false;
    }
    public static  void main(String[] args){
        Object o1 = new TestOverWriteEquals("123","haozhixin");
        Object o2 = new TestOverWriteEquals("456","chenmei");
        System.out.println(o1.equals(o2));//false
        Object o3 = new TestOverWriteEquals("123","haozhixin");
        Object o4 = new TestOverWriteEquals(null,"haozhixin");
        System.out.println(o1.equals(o3));//true
        System.out.println(o4.equals(o1));//false
    }
}

上述的方法能够准确的判断两个对象是否相等了，而且避免了因为左边对象的属性为null导致的空指针异常，但是这个方法有没有问题呢？我们来设计一个子类继承这个类测试下：

package JAVA原理及应用.HashCode和equals;

/**
 * Created by haozhixin on 2019/9/10.
 */
public class TestOverWriteEqualsChild extends TestOverWriteEquals {
    public String id;
    public String name;
    public TestOverWriteEqualsChild(String id,String name){
        super(id,name);
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public String getId() {
        return id;
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }
    public static void main(String[] args){
        Object obj1 = new TestOverWriteEqualsChild("123","haozhixin");
        Object obj2 = new TestOverWriteEqualsChild("123","haozhixin");
        Object obj3 = new TestOverWriteEquals("123","haozhixin");
        //false 因为调用的是父类的equals 方法，所以TestOverWriteEquals testOverWriteEquals = (TestOverWriteEquals) obj;强转完成。
        //在testOverWriteEquals.getId()的时候，得到的id是null
        System.out.println(obj1.equals(obj2));
        //true  在调用过程中一直可以获取类的属性
        System.out.println(obj1.equals(obj3));
        //false 在调用过程中，子类的属性获取不到，返回false
        System.out.println(obj3.equals(obj1));
    }
}

通过以上测试，我们发现这个重写的equals方法根本不具有对称性原则，所以算是重写失败了，那么我们应该怎么重写这个类呢？ 通过上边的代码分析我们知道问题的关键原因在于使用了instance of 会让子类钻空子。所以我们将父类的equals方法修改如下：

@Override
    public boolean equals(Object obj){
        if(obj!=null && obj.getClass()==this.getClass()){
            TestOverWriteEquals1 testOverWriteEquals = (TestOverWriteEquals1) obj;
            if(id==null||name==null){//防止因equals左边的类对象是null产生空指针异常
                return false;
            }
            return id.equals(testOverWriteEquals.getId())&&name.equals(testOverWriteEquals.getName());
        }
        return false;
    }

为什么都说重写equals方法必须重写hashcode方法

在Java中，为什么大家都说重写了equals方法都要进而重写Hashcode方法呢？
原因是以下两个：
（1）java的hashcode有一个通用的协定，即相等的对象必须具有相等的散列码（hashCode）。
如果不重写hashcode会违反这个协定。
（2）对于HashSet和HashMap这些基于散列值（hash）实现的类。HashMap的底层处理机制是以数组的方法保存放入的数据的(Node<K,V>[] table)，其中的关键是数组下标的处理。数组的下标是根据传入的元素hashCode方法的返回值再和特定的值异或决定的。如果该数组位置上已经有放入的值了，且传入的键值相等则不处理，若不相等则覆盖原来的值，如果数组位置没有条目，则插入，并加入到相应的链表中。检查键是否存在也是根据hashCode值来确定的。所以如果不重写hashCode的话，可能导致HashSet、HashMap不能正常的运作。

所以上边的类我们应该加上hashcode的重写方法：

 @Override
    public int hashCode() {
        StringBuilder sb = new StringBuilder();
        sb.append(id);
        sb.append(name);
        char[] charArr = sb.toString().toCharArray();
        int hash = 0;
        for(char c : charArr) {
            hash = hash * 131 + c;
        }
        return hash;
    }

以上，送给大家。

---

作者：select you from me
来源：优快云
版权声明：本文为博主原创文章，转载请附上博文链接！