对象本身有可比较性的,要怎么重写hashcode和equals方法呢?Comparator和Comparable有什么区别?

1. /*
   
2. 往hashset集合中存入自定义对象
   
3. 姓名和年龄相同为同一人，取出重复元素
   
4. */
   
5. import java.util.*;
   
6. class HashSetTest
   
7. {
   
8.         public static void sop(Object obj)
   
9.         {
   
10.                 System.out.println(obj);
    
11.         }
    
12.         public static void main(String[] args)
    
13.         {
    
14.                 //定义hashset
    
15.                 HashSet hs = new HashSet();
    
16.                 //添加元素
    
17.                 hs.add(new Person("a1",11));
    
18.                 hs.add(new Person("a2",12));
    
19.                 hs.add(new Person("a2",12));
    
20.                 hs.add(new Person("a3",13));
    
21.                
    
22.                 //迭代取出元素
    
23.                 Iterator it = hs.iterator();
    
24.                 while (it.hasNext())
    
25.                 {
    
26.                         //强转取出的元素
    
27.                         Person p = (Person)it.next();
    
28.                         //输出姓名和年龄
    
29.                         sop(p.getName()+"..."+p.getAge());
    
30.                 }
    
31.         }
    
32. }
    
33. class Person
    
34. {
    
35.         //定义 姓名 年龄
    
36.         private String name;
    
37.         private int age;
    
38.         //构造函数
    
39.         Person(String name,int age)
    
40.         {
    
41.                 this.name = name;
    
42.                 this.age = age;
    
43.         }
    
44.         //复写hashCode方法
    
45.         public int hashCode()
    
46.         {
    
47.                 //sop(this.name+"...hashCode");
    
48.                 return name.hashCode()+age;
    
49.         }
    
50.         //复写equals方法
    
51.         public boolean equals(Object obj)
    
52.         {
    
53.                 //判断传递的值是否是person类型
    
54.                 //instanceof 对象是不是特定类的实例
    
55.                 if(!(obj instanceof Person))
    
56.                         return false;
    
57.                 //强转 传递来的值
    
58.                 Person p = (Person)obj;
    
59.                 //返回 姓名 和年龄比较的结果
    
60.                 return this.name.equals(p.name)&&this.age==p.age;
    
61.         }
    
62.         //获取名字的方法
    
63.         public String getName()
    
64.         {
    
65.                 return name;
    
66.         }
    
67.         //获取年龄的方法
    
68.         public int getAge()
    
69.         {
    
70.                 return age;
    
71.         }
    
72. }
    
73. 
    

复制代码

Comparable接口和Comparator接口的区别：
Comparable 接口中是compareTo方法，compareTo方法中传递的是一个参数
Comparator接口中是compare方法，compare传递的是两个参数
实现Comparable接口，自定义类实现Comparable，让这个类创建的对象具备比较性，可以存储在TreeSet集合中。
实现Comparator接口，自定义实现Comparator，将这个类的对象传递给TreeSet集合的构造函数，让这个集合具备了比较性。

浅谈为何要重写 hashcode()与equals()
首先，这两个方法都来自于Object对象，根据API文档(1)public boolean equals(Object obj)，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true；注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。（2）public int hashCode() 返回该对象的哈希码值。支持该方法是为哈希表提供一些优点，例如，java.util.Hashtable提供的哈希表。
我们知道，如果不重写equals，那么比较的将是对象的引用是否指向同一块内存地址，重写之后目的是为了比较两个对象的value值是否相等。特别指出，此时，利用equals比较八大包装对象（如int，float等）和String类（因为该类已重写了equals和hashcode方法）对象时，默认比较的是值，在比较其它对象都是比较的引用地址。那产生了一个问题，为什么jdk中希望我们在重写equals时，非常有必要重写hashcode呢？
我的理解是hashcode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进行判断是否相同的。这样如果我们对一个对象重写了euqals，意思是只要对象的成员变量值都相等那么euqals就等于true，但不重写hashcode，那么我们再new一个新的对象，当原对象.equals（新对象）等于true时，两者的hashcode却是不一样的，由此将产生了理解的不一致，如在存储散列集合时（如Set类），将会存储了两个值一样的对象，导致混淆，因此，就也需要重写hashcode。为了保证这种一致性，必须满足以下两个条件：
(1)当obj1.equals(obj2)为true时，obj1.hashCode() == obj2.hashCode()必须为true
(2)当obj1.hashCode() == obj2.hashCode()为false时，obj1.equals(obj2)必须为false
下面，通过一个简单的例子来验证一下。
import java.util.*;
class BeanA {
private int i;
public BeanA(int i) {
this.i = i;
}
public String toString() {
return " " + i;
}
public boolean equals(Object o) {
BeanA a = (BeanA) o;
return (a.i == i) ? true : false;
}
public int hashCode() {
return i;
}
}
public class HashCodeTest {

public static void main(String[] args) {
HashSet<BeanA> set = new HashSet<BeanA>();
for (int i = 0; i <= 3; i++){
set.add(new BeanA(i));
}
System.out.println(set);
set.add(new BeanA(1));
System.out.println(set.toString());
System.out.println(set.contains(new BeanA(0)));
System.out.println(set.add(new BeanA(1)));
System.out.println(set.add(new BeanA(4)));
System.out.println(set);
}
}
我们在类BeanA中重写了equals和hashcode方法，这样在存储到HashSet数据集中，将保证不会出现重复的数据；如果把这两个方法去掉后，那些重复的数据仍会存入HashSet中，这就与HashSet强调的元素唯一性相违背，大家可以把这两个方法注释掉再运行一下。
因此，我们就可以理解在一些java类中什么情况下需要重写equals和hashcode。比如：在hibernate的实体类中，往往通过一个主键（或唯一标识符）来判断数据库的某一行，这就需要重写这两个方法。因为，Hibernate保证，仅在特定会话范围内，持久化标识（数据库的行）和Java标识是等价的。因此，一旦我们混合了从不同会话中获取的实例，如果希望Set有明确的语义，就必 须实现equals() 和hashCode()。

comparable&   Comparator    都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现的排序，Comparator是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义Comparator接口的方法compare()或在集合内实现Comparable接口的方法compareTo()。

Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String    Integer自己就可以完成比较大小操作）   

而Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。