关于equals和hashcode方法

首先声明一下，这篇文章仅仅讨论引用类型

所有引用类型都是继承自Object类，Object类有两个重要的方法:equals(),hashCode()经常被使用，虽然表面上你可能看不到你的代码里使用hashcode()。

Object类是这样实现equals方法的：

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

可见默认情况下==和equals()方法是一样的,即比较两个对象的地址。

从技术上来说，只要是通过new创建出来的实例，任何情况下equals和==都是false;

从业务上来说，有的时候我们希望即使不是同一个实例也可以相等：比如在系统中的不同组件之间，可以传递具有相同身份证信息的人的不同实例，但是在各个组件看来，这些不同实例对应的应该是同一个人，因为他们具有相同的身份证信息！

所以在开发过程中就产生了==不相等但是需要equals相等的矛盾！（因为==我们无法改变，所以业务逻辑只能寄希望于改变equals的实现）。

以身份证为某个人唯一标示作为例子，我们定义的时候应该是这样的：

/**
 * 具有相同身份证信息的人就是同一个人
 * 
 * @author Lucifer
 * 
 */
public class Person {

    private String name;
    private String identityCard;

    public Person(String name, String identityCard) {
        this.name = name;
        this.setIdentityCard(identityCard);
    }

    public String getName() {
        return name;
    }

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

    public String getIdentityCard() {
        return identityCard;
    }

    public void setIdentityCard(String identityCard) {
        this.identityCard = identityCard;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (!(obj instanceof Person)) {
            return false;
        }
        Person person = (Person) obj;

        return person.getIdentityCard().equals(this.identityCard);

    }
}

说到这里终于可以进入正题了，因为我们有了需要改变equals规则的需求。Object的hashcode有一些规约：

Returns a hash code value for the object. This method is supported for the benefit of hashtables such as those provided by java.util.Hashtable.

The general contract of hashCode is:

• Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
• If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
• It is not required that if two objects are unequal according to the java.lang.Object.equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.

As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java^TM programming language.)

红色字体部分经常被面试官问道，所以不管你想不想真正理解，你都应该记住：

1.如果两个object通过equals方法判断为相等，那么hashcode方法必须返回相同的整型值。

2.如果两个object通过equals方法判断为不相等，那么hashcode方法不要求必须返回不相等的整型值。但是程序员应该为不相等(通过equals方法判断的)的object返回不同的hashcode，以提高hashtables的性能。

这是我们就想到这个跟HashTable有什么关系呢，虽然没有强制不相等的时候重写hashCode方法，但是建议我们重写以提高HashTable的性能。

那么如何重写hashCode呢？

最简单的方法：如果你使用Eclipse开发，那么在需要重写hashCode和equals的类中右键选择source->Generate hashcode and equals

上面我们的例子用这个方法生成的代码如下：

/**
 * 具有相同身份证信息的人就是同一个人
 * 
 * @author Lucifer
 * 
 */
public class Person {

    private String name;
    private String identityCard;

    public Person(String name, String identityCard) {
        this.name = name;
        this.setIdentityCard(identityCard);
    }

    public String getName() {
        return name;
    }

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

    public String getIdentityCard() {
        return identityCard;
    }

    public void setIdentityCard(String identityCard) {
        this.identityCard = identityCard;
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((identityCard == null) ? 0 : identityCard.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (identityCard == null) {
            if (other.identityCard != null)
                return false;
        } else if (!identityCard.equals(other.identityCard))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

如果加上一个int类型的字段age，生成的代码如下：

@Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result
                + ((identityCard == null) ? 0 : identityCard.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

因为对于基本类型他们的值就是他们的HashCode。

当然，我们还注意到hashCode方法返回的是int类型。那按以上的实现方式会不会出现问题呢，比如我们把age改成long：

@Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + (int) (age ^ (age >>> 32));
        result = prime * result
                + ((identityCard == null) ? 0 : identityCard.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

对于超出int类型长度的long类型，只需要做一下位移操作，保证不超出int范围即可。

最后，奉上一段国外程序员给出的重写hashCode方法的原则：

1) Take a prime hash e.g. 5, 7, 17 or 31 (prime number as hash, results in distinct hashcode for distinct object)

2) Take another prime as multiplier different than hash is good.

3) Compute hashcode for each member and add them into final hash. Repeat this for all members which participated in equals.

4) Return hash

Read more: http://javarevisited.blogspot.com/2011/10/override-hashcode-in-java-example.html#ixzz3YHnchQTu