重新编写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/