java解惑之重载与覆写(equals与hashCode)
public class Name {
private String first, last;
public Name(String first, String last) {
this.first = first;
this.last = last;
}
public boolean equals(Object o) {
if (!(o instanceof Name))
return false;
Name n = (Name)o;
return n.first.equals(first) && n.last.equals(last);
}
public static void main(String[] args) {
Set s = new HashSet();
s.add(new Name("Mickey", "Mouse"));
System.out.println(s.contains(new Name("Mickey", "Mouse")));
}
}
两个Name实例在通过equals方法进行计算时，如果它们的姓相等且名也相等，则这两个Name 实例相等。姓和名是用在String中定义的equals方法来比较的。例如，下面的方法调用将返回true：
new Name("Mickey", "Mouse").equals(new Name("Mickey", "Mouse"))
该程序的main 方法创建了两个Name 实例，它们都表示Mickey Mouse。该程序将第一个实例放置到了一个散列集合中，然后检查该集合是否包含第二个实例。这两个Name 实例是相等的，因此看起来该程序似乎应该打印true，但答案却是false。
这里的bug 在于Name违反了hashCode约定。Name类覆写了equals方法，而hashCode约定要求相等的对象要具有相同的散列码。为了遵守这项约定，无论何时，只要你覆写了equals 方法，你就必须同时覆写hashCode 方法。因为Name类没有覆写hashCode方法，所以它从Object那里继承了其hashCode实现。这个实现返回的是基于标识的散列码，即不同的对象几乎总是产生不相等的散列值。
当程序将第一个Name实例放置到散列集合中时，该集合就会在某个散列位置上放置这个实例对应的项。该散列位置是基于通过实例的hashCode方法计算出来的散列值来选择的。当该程序在检查第二个Name实例是否包含在散列集合中时，它基于第二个实例的散列值来选择要搜索的散列位置。因为第二个实例有别于第一个实例，因此它极有可能产生不同的散列值。如果这两个散列值映射到了不同的位置，那么contains方法将返回false。
假设两个Name实例映射到了相同的位置，那又会怎样呢？我们所了解的所有的HashSet实现都进行了一种优化，即每一项在存储元素本身之外，还存储了元素的散列值。在搜索某个元素时，这种实现通过遍历集合中的项，去拿存储在每一项中的散列值与我们想要查找的元素的散列值进行比较，从而选取适当的散列位置。只有在两个元素的散列值相等的情况下，这种实现才会认为这两个元素相等。
对散列集合来说，这项优化并不足以使其能够搜索到正确的位置；两个Name实例必须具有相同的散列值才能让散列集合能够将它们识别为是相等的。要想订正该程序，只需在Name 类中添加一个恰当的hashCode 方法即可。
public int hashCode() {
return 37 * first.hashCode() + last.hashCode();
}
总之，当你在覆写一个方法时，如果它具有一个通用的约定，那么你一定要遵守它。对于大多数在Object中声明的非final的方法，都需要注意这一点。
public class Name {
private String first, last;
public Name(String first, String last) {
this.first = first; this.last = last;
}
public boolean equals(Name n) {
return n.first.equals(first) && n.last.equals(last);
}
public int hashCode() {
return 31 * first.hashCode() + last.hashCode();
}
public static void main(String[ ] args) {
Set s = new HashSet();
s.add(new Name("Donald", "Duck"));
System.out.println(
s.contains(new Name("Donald", "Duck")));
}
}
上面那个例子Name覆写了equals方法，但是没有覆写hashCode方法；而在本例中，Name覆写了hashCode方法，但是没有覆写equals方法。它确实声明了一个equals方法，但是那是个错误的声明。Name类声明了一个参数类型是Name而不是Object的equals方法。这个类的作者可能想要覆写equals方法，但是却错误地重载了它。
HashSet类是使用equals(Object)方法来测试元素的相等性的；Name类中声明一个equals(Name)方法对HashSet不造成任何影响。那么Name使用的是从Object继承而来的equals(Object)，这个方法两对象完全相同时才返回true。我们的程序中的main方法将一个Name实例插入到了散列集合中，并且测试另一个实例是否存在于该散列集合中，由此可知该测试一定是返回false的。对散列映射表而言，它们只是两个不相等的对象。
本例的教训是：当你想要进行覆写时，千万不要进行重载。为了避免无意识地重载，你应该机械地对你想要覆写的每一个超类方法都拷贝其声明，或者让你的IDE 帮你去做这些事。这样做除了可以保护你免受无意识的重载之害，而且还可以保护你免受拼错方法名之害。如果你使用的5.0 或者更新的版本，那么对于那些意在覆写超类方法的方法，你可以将@Override 注释应用于每一个这样的方法的声明上：
@Override public Boolean equals(Object o) { ... }
在使用这个注释时，除非被注释的方法确实覆写了一个超类方法，否则它将不能编译。对语言设计者来说，值得去考虑在每一个覆写超类方法的方法声明上都添加一个强制性的修饰符。
首先，这两个方法都来自于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
在某些时候，我们需要判断两个对象是否相等。Java的每个类都继承于Object类。它使用equals()及hashCode()这两个方法来判断两个Object是否相等。
1. equals()
需要满足5点：
1 自省：对于任一非null引用x，x.equals(x)应返回true；
2 反射：对于任一非null引用x及y，仅在y.equals(x)返回true时，x.equals(y)才返回true；
3 传递：对于任一非null引用x、y及z，如果x.equals(y)为true，而且y.equals(z)为true，则x.equals(z)应返回true；
4 稳定：对于任一非null引用x及y，如果用于比较的信息没有改变，无论多少次调用x.equals(y)都会恒定地返回true或false；
5 对于任一非null引用x，x.equals(null)应返回false。
Object的默认实现是只要在两个Object的引用相等时，才会返回true，即return x == y;
如果要覆盖(override)此方法，需要同时覆盖hasCode()，要求是：两个相等的对象必须有相等的hash code。
2. hashCode()
其必须遵循的约定是：
1 如果对象equals, 则hashCode一定相等;
2 如果equals()返回false，这两个对象的hashCode()可能相同。但不等的两个对象返回不同的int值可以提高hashtables的运行效率。
作为常理，不相等的对象的hasCode()应可能地返回不同的int值。
3. 对象是否相等的规则
1 判断两个对象的hashCode是否相等; 如果不相等，认为两个对象也不相等, 完毕.
2 如果相等, 再调用equals方法.
4. hashCode最大的用处是什么呢?
Java中的集合（Collection）有两类，一类是List，再有一类是Set。
你知道它们的区别吗？前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。
那么这里就有一个比较严重的问题了：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？
这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。
Java采用了哈希表的原理, 哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上. 初学者可以这样理解，hashCode方法实际上返回的就是对象存储的物理地址（实际可能并不是）。
有了hashCode,当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。
如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，
就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。
所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次.
5. 为什么在HIBERNA里要重写hashCode和equals这两个方法?
在hibernate中，经常使用set集合来保存相关对象，而set集合是不允许重复的, so, 道理同4.