两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话应该是对的吧！

[yyouyou]

对象值到底指什么？(x.equals(y) == true)应该并不代表对象值相同
class A
{
A(){}
public boolean equals(A a)
{
return true;
}
}
public class EqualsTest
{
public static void main(String argv[])
{
A a1 = new A();
A a2 = new A();
System.out.println(a1.equals(a2));
System.out.println(a1.hashCode());
System.out.println(a2.hashCode());
}
}

[ericbu]

好强的贴！
Mark！

[I_Believe_]

不好意思刚才掉线了！！发完这贴真下了，有事！！
TO: shine333(enihs) ,从语法角度你可能是指HASHCODE（）与TOSTRING（）这样才算有强制关系的吧！！但是equals（）与hashCode在使用某些容器时确实有有强制性！说他们分不开不过分，容器很多地方用得到！
TO treeroot(旗鲁特)：你钻牛角尖了

[shine333]

但使用容器时，仍然是没有强制性，因为容器都是接口，实现方式千差万别，

连java.util.Map的class javadoc的最后都说

More generally, implementations of the various Collections Framework interfaces are free to take advantage of the specified behavior of underlying Object methods wherever the implementor deems it appropriate.

也就是说，即使容器，实现的时候，也可以根本不用hashCode或者equals，甚至可能直接用==

当然，这个情况很少会发生。所以，我也不再谈强制性的问题。

关于“equals（）是为hashCode相同而设定的”，此乃大谬也。

我也不说两者之间互不隶属（不光语法强制无关，而且是在逻辑上，规范上）

宇宙之中，各种事物何其之多，各种情况不可计数，岂是一个小小的32bit int可以区分？！难道因为hashCode碰巧相同，equals也要为了hashCode相同而忍气吞声？

[shine333]

又来了一个toString()，这方面不想回答。估计您从来没有自己override过。

话又说回来，equals true/false,而hashCode理论上需要32-bit内平均分布，请问怎么依赖一个只有两种可能的事物，得出一个有2^32种可能的事物

[treeroot]

潜力贴

[kingofhawks]

treeroot(旗鲁特) ( )
equals（）是为hashCode不同而设定的！！！

又是谬论!
只有使用哈希表是才使用hashCode,equals在任何地方都会用到.
如果你需要使用equals方法或者任何容器,就不要忽略它的存在.
只有你需要使用哈希表时你才需要关注hashCode,而且一般要足够离散!
---------------正解.好多时候我们实现equals的时候都可以不用管hashCode.

[kingofhawks]

完全同意treeroot(旗鲁特) ( ) 的观点.请看Sun JDK 文档是怎么说的吧.
The general contract of hashCode is:

Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.
实际上,如果我们的对象并不会放到HashMap中去的话,根本就不需要实现hashCode.是不是这么理解呢?

[shine333]

基本上是这样，不过更准确的说法，并不一定是HashMap/table，

而是那些根据上面这个规范，进行hash操作的地方

[treeroot]

事实上就是哈希表,如果它使用了hashCode其实他就是哈希表的实现

jdk中包括 HashMap,LinkedHashMap,IdentityHashMap,Hashtable

楼上还能列举其他情况?

[treeroot]

当然HashSet本质上是HashMap
LinkedHashSet本质上是LinkedHashMap

[shine333]

我说的是“不是HashMap/Hashtable”，我没有讲数据结构中的哈希表

而且为什么一定要从JDK里面找？org.apache.commons.collection就不错:P

[treeroot]

哈希表虽然有各种实现,但是本质上是一样的,都是基于哈希函数

[kingofhawks]

org.apache.commons.collection里边应该也有类似hashmap的东东吧,也是只有在用到这些东西时才需要实现hashCode()么?没用过,请指教.

[jimshen]

总结一下，equals（）是对象相等性比较，hashCode（）是计算对象的散列值，当然他们的语句是对象的属性。

对于equals，一般我们认为两个对象同类型并且所有属性相等的时候才是相等的，在类中必须改写equals，因为Object类中的equals只是判断两个引用变量是否引用同一对象，如果不是引用同一对象，即使两个对象的内容完全相同，也会返回false。当然，在类中改写这个equals时，你也可以只对部分属性进行比较，只要这些属性相同就认为对象是相等的。

对于hashCode，只要是用在和哈希运算有关的地方，前面很多兄弟都提到了，和equals一样，在你的类中也应该改写。当然如果两个对象是完全相同的，那么他们的hashCode当然也是一样的，但是象前面所述，规则可以由你自己来定义，因此两者之间并没有什么必然的联系。

当然，大多数情况下我们还是根据所有的属性来计算hashCode和进行相等性比较。

[jimshen]

对不起，输入错误。

总结一下，equals（）是对象相等性比较，hashCode（）是计算对象的散列值，当然他们的依据是对象的属性。

[成富]

如果两个对象是equal的话，则hashCode必须相同。
而不相等的两个对象的hashCode不并不相同，但是如果不相同可以提高hash table的效率。

－－－《Effective Java》 P36

[vvpang]

对的。。

[jimshen]

对的，相等性比较和hashCode的计算依据可以由类的编写者确定

[yyouyou]

谢谢大家！
结帖！

[liu_you]

API的规范中有这样一句:
Note that it is generally necessary to override the hashCode method whenever this method is overridden,so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.



public boolean equals(Object obj)Indicates whether some other object is "equal to" this one.
The equals method implements an equivalence relation on non-null object references:

It is reflexive: for any non-null reference value x, x.equals(x) should return true.
It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
It is 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) should return false.
The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).

Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.


Parameters:
obj - the reference object with which to compare.
Returns:
true if this object is the same as the obj argument; false otherwise.