承接上文：
Comparable接口：针对排序list
问题：上面的算法根据什么确定容器中对象的“大小”顺序？
所有可以“排序”的类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法
Publicint compareTo(Object obj)
返回0：表示this==obj
返回正数：表示this>obj
返回负数：表示this<obj
实现了Comparable接口的类通过实现comparaTo方法从而确定该对象的排序方式
equals()与hashCode()：保证不重复
由来：
要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。
于是，Java采用了哈希表的原理。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。
这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。
规则：
所以，Java对于eqauls方法和hashCode方法是这样规定的：
1.如果两个对象相同，那么它们的hashCode值一定要相同；
2.如果两个对象的hashCode相同，它们并不一定相同（这里说的对象相同指的是用eqauls方法比较）。如不按要求去做了，会发现相同的对象可以出现在Set集合中，同时，增加新元素的效率会大大下降。
3.equals()相等的两个对象，hashcode()一定相等；equals()不相等的两个对象，却并不能证明他们的hashcode()不相等。
在object类中，hashcode()方法是本地方法，返回的是对象的地址值，而object类中的equals()方法比较的也是两个对象的地址值，如果equals()相等，说明两个对象地址值也相等，当然hashcode()也就相等了；
在String类中，equals()返回的是两个对象内容的比较，当两个对象内容相等时Hashcode()方法根据String类的重写代码的分析，也可知道hashcode()返回结果也会相等。
以此类推，可以知道Integer、Double等封装类中经过重写的equals()和hashcode()方法也同样适合于这个原则。当然没有经过重写的类，在继承了object类的equals()和hashcode()方法后，也会遵守这个原则。
总结：
hashCode()方法被用来获取给定对象的唯一整数。这个整数被用来确定对象被存储在HashTable类似的结构中的位置。默认的，Object类的hashCode()方法返回这个对象存储的内存地址的编号。 hashCode()和equals()定义在Object类中，这个类是所有java类的基类，所以所有的java类都继承这两个方法。
如果我们不重写这两个方法，将几乎不遇到任何问题，但是有的时候程序要求我们必须改变一些对象的默认实现。
举例说明：
public class TestString{
public static void main(String[] args){
String s1="Hello";
String s2="World";
String s3="Hello";
System.out.println(s1 == s3);
s1=new String("hello");
s2=new String("hello");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
}
}
以上的正确执行是因为我们已经默认重写了String类的equals()方法和hashCode()方法。但是如果是Object类呢？
import java.util.HashSet;
import java.util.Set;
public class TestEquals1{
public static void main(String[] args){
Cat cl=new Cat(1,2,3);
Cat c2=new Cat(1,2,3);
System.out.println(cl==c2);
System.out.println(cl.equals(c2));
}
}
class Cat{
int color,height,weight;
public Cat(int color,int height,int weight){
this.color=color;
this.height=height;
this.weight=weight;
}
}
public class TestEquals{
public static void main(String[] args){
Cat cl=new Cat(1,2,3);
Cat c2=new Cat(1,2,3);
System.out.println(cl==c2);
System.out.println(cl.equals(c2));
}
}
class Cat{
int color,height,weight;
public Cat(int color,int height,int weight){
this.color=color;
this.height=height;
this.weight=weight;
}
public boolean equals(Object obj){
if(obj==null)return false;
else{
if(obj instanceof Cat){
Cat c=(Cat)obj;
if(c.color==this.color && c.height==this.height && c.weight==this.weight){
return true;
}
}
}
return false;
}
}
So are we done?没有，让我们换一种测试方法来看看。
上面的程序输出的结果是两个。如果两个cat对象equals返回true，Set中应该只存储一个对象才对，而且System.out.println(cat.contains(newCat(1,2,3)));判断是否存在时，结果输出为false，如图：
那么问题在哪里呢？
我们忘掉了第二个重要的方法hashCode()。就像JDK的Javadoc中所说的一样，如果重写equals()方法必须要重写hashCode()方法。我们加上下面这个方法，程序将执行正确。
public int hashCode()
{
final int PRIME =31;
int result = 1;
result = PRIME * result ;
return result;
}
再总结：
以上这些都是针对容器来说的（如何判断set中不重复，如何判断list中的顺序），当然最主要的是解释为什么重写equals()方法必须要重写hashCode()方法的问题。
根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode方法，它们仅仅是两个对象。因此，违反了“相等的对象必须具有相等的散列码”。
所以只要重写了equals()，一定要重写hashCode，否则Hash表都会失效，工作不正常。即便你用equals方法比较得到两个对象是相等的结论那你也得不到相同的哈希码
即如果cat类只重写了equals（），hashcode没有被重写，加入元素时使用的hashcode（）是继承于set<-collection<-object的，所以计算的hashcode值不同，存储位置不同，则认为元素不相同，也就能明白为什么上面的判断是否存在（System.out.println(cat.contains(newCat(1,2,3)))）时输入的结果为false了。