关于equals和hashcode方法

一：生成equals的约定。

在《Effective Java》中说明了覆盖equals方法时的一些规则（约定），下面是约定的内容，来自Object的规范【JavaSE6】：
equals方法实现了等价关系
1) 自反性：对于任何非null的引用值x，x.equals(x)一定返回true。
2) 对称性：对于任何非null的引用值x,y，当且y.equals(x)返回true时，x.equals(y)必须返回true。
3) 传递性：对于任何非null的引用值x,y,z，如果x.equals（y）返回true，并且y.equals(z)返回true，那么x.equals(z)必须返回true。
4) 一致性：对于任何非null的引用值x和y，只要equals的比较操作在对象中所用的信息没有被修改，多次调用x.equals(y)就会一致第返回true。或者一致低返回false。
5) 对于任何非null的引用值x，x.equals(null)必须返回false。

对于hashCode的约定是：如果两个对象的equals方法返回true，那么hashcode一定相等。

二、Eclipse自动生成的equals方法和hashcode方法

下面以一个类Point类分析equals和hashcode方法。

public class Point{
    private int x;
    private int y;
    private String label;

    public Point(int x,int y,String label){
        this.x = x;
        this.y = y;
        this.label = label;
    }
}

下面用Eclipse为这个Point自动生成hashCode方法和equals方法。我们先看hashCode方法。代码如下：

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

首先有一个素数31，在很多类下面生成的的hashCode方法都是使用素数31，然后不断用这个prime乘以当前的hashCode值并加上类属性的hashCode值，直到所有的元素都被累加。

再看equals方法，第三个if语句通过使用getClass方法来判断两个对象是不是属于同一个类，如果不是同一个类，则返回false。：

    @Override
    public boolean equals(Object obj) {
        if (this == obj)    //1.先比较地址，看看是不是同一个对象
            return true;
        if (obj == null)    //2.如果obj为null，立刻返回false 
            return false;
        if (getClass() != obj.getClass())  //3.判断是不是同一个类
            return false;
        Point other = (Point) obj;     //这个时候已经判断是同一个类型了，而且不为null
        if (label == null) {         //4.比较元素，非基本类型要调用他们的equals方法，在调用之前先判断是不是null。
            if (other.label != null)
                return false;
        } else if (!label.equals(other.label))
            return false;
        if (x != other.x)
            return false;
        if (y != other.y)
            return false;
        return true;
    }

关于getClass的使用可以参考关于java中getClass()和getSuperClass()，关键点为：使用super.getClass()和this.getClass()方法返回的当前运行类的Class,而不是其基类，使用this.getClass().getSuperclass()方法返回的才是父类的Class

三、Object默认的方法。

如果不覆盖equals和hashcode方法，将使用Object的默认实现，Object类的hashCode方法是native方法，是根据对象的地址生成的hash值。Object的equals实现如下(Object是一个类，声明为public class Object)，由此看见如果不重写equals，Object是直接比较是不是同一个对象（地址）：

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

四、equals、hashCode方法在集合HashMap、HashSet中的应用。

我们先看一个测试程序，程序中的Point重写了equals和hashCode方法。

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        Point p1 = new Point(1,2,"abc");
        Point p2 = new Point(1,2,"abc");
        HashSet<Point> points = new HashSet<Point>();
        points.add(p1);
        System.out.println(points.contains(p2));
    }
}

程序输出true，我们放进去的是p1，但是程序显示也包含p2。我们查看contains方法的实现：

    public boolean contains(Object o) {
        return map.containsKey(o);
    }

Java中的HashSet是用HashMap实现的，这里实际调用了HashMap的containsKey方法，我们跟进去看：

    public boolean containsKey(Object key) {
        return getEntry(key) != null;
    }

    final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key.hashCode());
        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;
    }

在getEntry方法中，首先是获取key（也就是我们传进去的p2）的hashCode，并对这个hashCode进行再hash，生成一个最终的hash值，然后在table中根据这个hash值查找其下标，indexFor的实现为

    static int indexFor(int h, int length) {
        return h & (length-1);
    }

跟取余是一个效果，对于地址是一样的元素，hashMap采用了拉链法来处理冲突，即存在一个链表Entry<K,V> e，for循环的作用就是遍历这个链表，在比较是否相等的if语句中，我们看到实际上先进行了hash值的比较。
e.hash == hash如果hash值不等，继续遍历链表，如果hash值相等，再看看equals是否返回true，如果返回true则表示查找成功，返回元素。