重新编写equals()方法，hashCode()方法，以及toString()，提供自定义的相等标准，以及自描述方法

下面给出一个实例，重新编写equals()方法，提供自定义的相等标准

public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person("孙悟空", "1234");
        Person p2 = new Person("孙行者", "1234");
        Person p3 = new Person("孙大圣", "12345");
        System.out.println("p1和p2是否相等？" + p1.equals(p2));
        System.out.println("p1和p3是否相等？" + p1.equals(p3));
        System.out.println("p2和p3是否相等？" + p2.equals(p3));
    }
}

class Person {
    private String name;
    private String id;

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

    public String getId() {
        return this.id;
    }
    public boolean equals(Object obj) {
        //如果两个对象为同一个对象
        if( this == obj) {
            return true;
        }
        //当obj不为null，其它是Person类的实例时
        if( obj != null && obj.getClass() == Person.class) {
            Person obj2 = (Person)obj;
            //并且当前对象的id与obj对象的id相等才可判断两个对象相等
            if (this.getId().equals(obj2.getId())) {
                return true;
            }
        }
        return false;
    }
}

上述实例运行结果显示：
p1和p2是否相等？true

p1和p3是否相等？false

p2和p3是否相等？false

通常而言，正确地重写equals方法应该满足下列条件：

• 自反性：对任意x，x.equals(x)一定返回true。
• 对称性：对任意x和y，如果y.equals(x)返回true，则x.equals(y)也返回true。
• 传递性：对任意x，y，z，如果x.equals(y)返回true，y.equals(z)返回true，则x.equals(z)一定返回true。
• 一致性：对任意x和y，如果对象中用于等价比较的信息没有改变，那么无论调用x.equals(y)多少次，返回的结果应保持一致，要么一直是true，要么一直是false。
• 对任何不是null的x，x.equals(null)一定返回false。

特别注意：

重新equals()方法后，一定要重写hashCode()方法，否则会引起一些意想不到的错误。

所以，可以为上面的代码添加如下的hashCode()方法。

public int hashCode() {
    final int PRIME = 31;
    int result = 1;
    result = PRIME * result + getId().hashCode();
    return result;
}

注意：不同类型hashCode值的计算可以采用如下公式。

Field类型	计算公式
boolean	hashCode=(f?0:1);
整数类型（byte，short，char，int）	hashCode=(int)f;
long	hashCode=(int)(f^(f>>>32));
float	hashCode=Float.floatToIntBits(f);
double	long l=Double.doubleToLongBits(f); hashCode=(int)(l^(l>>>32);
普通引用类型	hashCode=f.hashCode();

使用系数为31的原因如下：

• 31是一个素数，素数作用就是如果我用一个数字来乘以这个素数，那么最终的出来的结果只能被素数本身和被乘数还有1来整除！。(减少冲突)
• 31可以 由i*31== (i<<5)-1来表示,现在很多虚拟机里面都有做相关优化.（提高算法效率）
• 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址越大，所谓的“冲突”就越少，查找起来效率也会提高。（减少冲突）
• 并且31只占用5bits,相乘造成数据溢出的概率较小。

实例：

Java中的集合有两类，一类是List，一类是Set。List内的元素是有序的，元素可以重复。Set元素无序，但元素不可重复。

下面，通过一个实例来加深对equals和hashCode方法的理解。

import java.util.HashSet;

public class HashSetAndHashCodeTest {
    public static void main(String[] args) {
        HashSet<Point1> hs1 = new HashSet<Point1>();
        Point1 p11 = new Point1(3, 3);
        Point1 p12 = new Point1(3, 3);
        Point1 p13 = new Point1(3, 5);
        hs1.add(p11);
        hs1.add(p11);
        hs1.add(p12);
        hs1.add(p13);
        System.out.println(hs1.size()); //答案是3


        HashSet<Point2> hs2 = new HashSet<Point2>();
        Point2 p21 = new Point2(3, 3);
        Point2 p22 = new Point2(3, 3);
        Point2 p23 = new Point2(3, 5);
        hs2.add(p21);
        hs2.add(p22);
        hs2.add(p23);
        System.out.println(hs2.size()); // 答案是2。p21和p22被认为是同一个对象。


        HashSet<Point3> hs3 = new HashSet<Point3>();
        Point3 p31 = new Point3(3, 3);
        Point3 p32 = new Point3(3, 3);
        Point3 p33 = new Point3(3, 5);
        hs3.add(p31);
        hs3.add(p32);
        hs3.add(p33);
        System.out.println(hs3.size()); // 可能是2，可能是3。因为根据内存地址算出的hashcode不知道是否在一个区域。
    }
}

/**
 * 1 没有重写hashCode和equals的方法 
 */
class Point1 {
    private int x;
    private int y;

    public Point1(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

/**
 * 2 重写hashCode和equals的方法 *
 */
class Point2 {
    private int x;
    private int y;

    Point2(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + x;
        result = prime * result + y;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;
        if (getClass() != obj.getClass()) return false;
        Point2 other = (Point2) obj;
        if (x != other.x) return false;
        if (y != other.y) return false;
        return true;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}


/**
 * 3 没有重写hashCode的方法，但重写equals的方法
 */
class Point3 {
    private int x;
    private int y;

    Point3(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;
        if (getClass() != obj.getClass()) return false;
        Point3 other = (Point3) obj;
        if (x != other.x) return false;
        if (y != other.y) return false;
        return true;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

对于自描述方法toString()，系统默认的方法如下：

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

这样得到的并非自描述信息，而是实例的内存地址。所以，针对上面的Point1类，可以给出下面的自描述方法：

public String toString() {
    return getClass().getName() + "@[x=" + this.getX() + ", y=" + this.getY() + "]";
}

 

参考内容：

• http://www.oschina.net/question/82993_75533
• http://www.2cto.com/kf/201211/168714.html
• http://howtodoinjava.com/2012/10/09/working-with-hashcode-and-equals-methods-in-java/