Obey the general contract when overriding equals
先了解equals 和 == 的区别，如果不重写equals， equals比较的仅仅只是是否引用同一个对象，==更多的是比较基本数值。当我们创建一些对象的时候。
当对象是单例模式不需要进行 equals 重写。
Reflexive: For any non-null reference values x,x.equals(x) must return true.
Symmetric:For any non-null reference values x and y,x.equals(y) must return true if and only if y.equals(x) returns true
Transitive:For any non-null reference values x,y,z,if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) must return true.
Consistent: For any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
For any non-null reference value x,x.equals(null) must return false.
以及，要明白hashcode的作用，与equals的关系。
package all; import java.util.Collection;
import java.util.HashSet; public class Test5 { public static void main(String[] args) {
// TODO Auto-generated method stub
Collection c = new HashSet ();
Address s1 = new Address("05");
Address s2 = new Address("05");
c.add(s1);
c.add(s2);
//HashSet()有这个机制，当add的对象发现它hashcode和自己里面已经有的已经相等，自己就会进行相等的对象equals判断，判断为
//相等，set不会储存相同的值，所以就当只存了一个对象。hashcode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进行判断是否相同的。
//详情 http://www.importnew.com/8701.html 关键点 一些collection的比较先从hashcode开始，所以才能快速。
System.out.println("----------------");
System.out.println(s1.equals(s2));
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(c); }
} class Address{
private String addressName;
public Address(String addressName){
this.addressName=addressName;
} public String toString(){
return this.addressName;
} @Override
public boolean equals (Object o){
if (this==o){//对象自身相等原则
return true;
}
if (o==null){//空值返回false 原则
return false;
}
if (o.getClass()!=getClass()){// 类型相同原则
return false;
} Address addr = (Address) o;//之后是实例化进行逻辑比较
if (!addr.addressName.equals(this.addressName)){
return false;
} System.out.println("Use equals!");
return true;
} @Override
public int hashCode(){//hashcode值 很重要，尤其是涉及collection。
return this.addressName.hashCode();
}
}
/*
输出以下：
Use equals!
----------------
Use equals!
true
1541
1541
[05]
会发现在分割线之上凭空多一个 use equals？ 这是因为在 hashset 添加的时候，会先进行hashcode 进行比较，一样hashcode值得对象调用equals
比较得出完全一样的对象，根据hashset不重复的特性，最后只有一个值 05 ，如果试着把hashcode 方法去掉 ，则在第一步hashcode值判断就会不一样，
不会进行下一步的 equals 判断，则会输出两个 05，而实际我们希望他们是同一个对象。 */
但是如果集合中已经存在一万条数据或者更多的数据，如果采用equals方法去逐一比较，效率必然是一个问题。此时hashCode方法的作用就体现出来了，当集合要添加新的对象时，先调用这个对象的hashCode方法，得到对应的hashcode值，实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的hashcode值，如果table中没有该hashcode值，它就可以直接存进去，不用再进行任何比较了；如果存在该hashcode值， 就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址，所以这里存在一个冲突解决的问题，这样一来实际调用equals方法的次数就大大降低了，说通俗一点：Java中的hashCode方法就是根据一定的规则将与对象相关的信息（比如对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值。
也就是说对于两个对象，如果调用equals方法得到的结果为true，则两个对象的hashcode值必定相等；
如果equals方法得到的结果为false，则两个对象的hashcode值不一定不同；
如果两个对象的hashcode值不等，则equals方法得到的结果必定为false；
如果两个对象的hashcode值相等，则equals方法得到的结果未知。
Cosider implementing Comparable
Comparable 接口的重写有利于 排序，在遇见一些Collection 的时候 。 除了Comparable 还有Comparator ，前者是比较接口 在类中实现，一个是比较器，创建一个类来实现，代码如下。
public class Cat implements Comparable<Cat> {
private int age;
private String name;
public Cat(int age,String name){
this.name=name;
this.age=age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Cat o) {//重写比较接口
// TODO Auto-generated method stub
return (this.age-o.age);
}
}
public class MyComparator implements Comparator<Cat>{//比较器的扩展
@Override
public int compare(Cat arg0, Cat arg1) {
// TODO Auto-generated method stub
return (arg1.getAge()-arg0.getAge());
}
}
public class Test2 {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
ArrayList<Cat> list = new ArrayList<Cat>();
list.add(new Cat(1,"1"));
list.add(new Cat(5,"5"));
list.add(new Cat(2,"2"));
list.add(new Cat(4,"4"));
list.add(new Cat(3,"3"));
Collections.sort(list);
for (Cat a:list){
System.out.println(a.getAge());
}
Collections.sort(list, new MyComparator());
for (Cat a:list){
System.out.println(a.getAge());
}
}
}
/*
输出
1
2
3
4
5
5
4
3
2
1
*/