hashcode改写

另一种方法：自己定义一个类B实现Comparator类并实现compare方法，

hashCode() 是用来产生哈希玛的，而哈希玛是用来在散列存储结构中确定对象的存储地址的，（这一段在 Java编程思想 中讲的很清楚的）象util包中的 带 hash 的集合类都是用这种存储结构 ：HashMap,HashSet, 他们在将对象存储时（严格说是对象引用），需要确定他们的地址吧， 而HashCode()就是这个用途的，一般都需要重新定义它的，因为默认情况下，由 Object 类定义的 hashCode 方法会针对不同的对象返回不同的整数，这一般是通过将该对象的内部地址转换成一个整数来实现的，现在举个例子来说， 就拿HashSet来说 ，在将对象存入其中时，通过被存入对象的 hashCode() 来确定对象在 HashSet 中的存储地址，通过equals()来确定存入的对象是否重复，hashCode() ，equals()都需要自己重新定义，因为hashCode()默认前面已经说啦，而equals() 默认是比较的对象引用，你现在想一下，如果你不定义equals()的话，那么同一个类产生的两个内容完全相同的对象都可以存入Set，因为他们是通过 equals()来确定的，这样就使得HashSet 失去了他的意义，看一下下面这个：

public class Test {

public static void main(String[] args) {

HashSet set = new HashSet();

for (int i = 0; i <= 3; i++){

set.add(new Demo1(i,i));

}

System.out.println(set);

set.add(new Demo1(1,1));

System.out.println(set);

System.out.println(set.contains(new Demo1(0,0)));

System.out.println(set.add(new Demo1(1,1)));

System.out.println(set.add(new Demo1(4,4)));

System.out.println(set);

}

private static class Demo1 {

private int value;

private int id;

public Demo1(int value,int id) {

this.value = value;

this.id=id;

}

public String toString() {

return " value = " + value;

}

public boolean equals(Object o) {

Demo1 a = (Demo1) o;

return (a.value == value) ? true : false;

}

public int hashCode() {

return id;

}

}

}

你分别注释掉hashCode()和 equals()来比较一下他们作用就可以拉，关键要自己动手看看比较的结果你就可以记得很清楚啦

如果还不是很明确可以再看另一个例子:

public final class Test {

public static void main(String[] args) {

Map m = new HashMap();

m.put(new PhoneNumber(020, 12345678), "shellfeng");

System.out.println(m.get(new PhoneNumber(020, 12345678)));

}

private static class PhoneNumber {

/**

* 区号

*/

private short areaCode;

/**

* 扩展号

*/

private short extension;

public PhoneNumber(int areaCode, int extension) {

this.areaCode = (short) areaCode;

this.extension = (short) extension;

}

public boolean equals(Object o) {

if (o == this) {

return true;

}

if (!(o instanceof PhoneNumber)) {

return false;

}

PhoneNumber pn = (PhoneNumber) o;

return pn.extension == extension && pn.areaCode == areaCode;

}

/**

* @see java.lang.Object#hashCode()

* @return result就是我们得到的散列值,其实我们的计算过程可以多种,这里只不过是一个例子,需要你的灵活运用,使其接近你需要的理想结果

*/

public int hashCode() {

int result = 17;

result = 37 * result + areaCode;

result = 37 * result + extension;

return result;

}

}

}

还是那句话:你注释掉hashCode()比较一下他们作用就可以拉，关键要自己动手看看比较的结果你就可以记得很清楚啦

总结

hashCode() 方法使用来提高Map里面的搜索效率的,Map会根据不同的hashCode()来放在不同的桶里面,Map在搜索一个对象的时候先通过 hashCode()找到相应的桶,然后再根据equals()方法找到相应的对象.要正确的实现Map里面查找元素必须满足一下两个条件:

(1)当obj1.equals(obj2)为true时obj1.hashCode() == obj2.hashCode()必须为true

(2)当obj1.hashCode() == obj2.hashCode()为false时obj.equals(obj2)必须为false

Java中的集合（Collection）有两类，一类是List，再有一类是Set。你知道它们的区别吗？前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。

那么这里就有一个比较严重的问题了：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？这就是Object.equals方法了。

但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。

也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。

哈 希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。我们可以认为hashCode方法返回的就是对象存储的物理地址（实际可能并不是,例 如:通过获取对象的物理地址然后除以8再求余,余数几是计算得到的散列值,我们就认为返回一个不是物理地址的数值,而是一个可以映射到物理地址的值）。

这 样一来，当集合要添加

改写equals时总是要改写hashCode

============================================================

java.lnag.Object中对hashCode的约定：

1. 在一个应用程序执行期间，如果一个对象的equals方法做比较所用到的信息没有被修改的话，则对该对象调用hashCode方法多次，它必须始终如一地返回同一个整数。

2. 如果两个对象根据equals(Object o)方法是相等的，则调用这两个对象中任一对象的hashCode方法必须产生相同的整数结果。

3. 如果两个对象根据equals(Object o)方法是不相等的，则调用这两个对象中任一个对象的hashCode方法，不要求产生不同的整数结果。但如果能不同，则可能提高散列表的性能。

有一个概念要牢记，两个相等对象的equals方法一定为true, 但两个hashcode相等的对象不一定是相等的对象。

所以hashcode相等只能保证两个对象在一个HASH表里的同一条HASH链上，继而通过equals方法才能确定是不是同一对象，如果结果为true, 则认为是同一对象不在插入，否则认为是不同对象继续插入。

Object的代码：

public String toString () {

return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());

}

public boolean equals (Object o) {

return this == o;

}

/**

* Answers an integer hash code for the receiver. Any two

* objects which answer true when passed to

* .equals must answer the same value for this

* method.

*

* @author OTI

* @version initial

*

* @return int

* the receiver's hash.

*

* @see#equals

*/

public native int hashCode();

篇三：覆盖equals()与hashCode()

一切理论都是空话，只有结合具体实例来证明你的理论，理论才称得上真正的理论！我们在学习Java的过程中，要掌握的知识太多，只有我们自己去把书上或网上的理论结合上自己的实例，那我们才算是真正的掌握。要不然，我们只会是暂时性的理解！

Java对于equals方法和hashCode方法是这样给定的：

1）如果两个对象相同，那么他们的hashCode值一定相同；

2）如果连个对象的hashCode相同，它们并不一定相同

HashCode 是一种编码方式，在Java中，每个对象都会有一个hashCode，Java可以通过这个hashCode值来识别一个对象。HashCode实现了一种无顺序元素排列

Java语言对equals()的要求如下，这些要求是必须遵循的：

1）自反性(反射性)：对于任何非空的引用x，x.equals(x)必须返回true。

2）对称性：对于任何非空的引用x，如果x.equals(y)返回时true，那么y.equals(x)

也应该返回时true。

3）传递性(类推性)：如果x.equals(y)返回时true，那么y.equals(z)也应该返回时

true，那么z.equals(x)也应该返回true。

4）一致性：如果x.equals(y)返回时true，只要x和y内容一直不变，不管你重复

x.equals(y)多少次，返回都是true。

5）任何情况下，x.equals(null)，永远返回是false；x.equals(和x不同类型的对象

永远返回false)。

equals()方法和hashCode()这两个方法都是从object类中继承过来的。

equals()方法在object类中定义如下：

public boolean equals(Object obj) {

return (this == obj);

}

可以看出equals()方法比较引用是否相同。但在String、Math、Integer、Double…等这些封装类在使用equals()方法时，已经覆盖了object类的equals()方法。

如在String类中equals()方法定义如下：

public boolean equals(Object anObject) {

if (this == anObject) {

return true;

}

if (anObject instanceof String) {

String anotherString = (String) anObject; int n = count;

if (n == anotherString.count) {

char v1[] = value;

char v2[] = anotherString.value; int i = offset; int j = anotherString.offset; while (n-- != 0) { if (v1[i++] != v2[j++])return false; } return true;} } return false; }

很明显，这是进行的内容比较，而已经不再是地址的比较。一次类推Double、Integer、Math…等等这些类都是重写了equals()方法的，从而进行的是内容的比较。基本类型是进行值的比较，不在介绍！

hashCode()方法，在object类中定义如下：

public native int hashCode(); 说明这是一个本地方法，它的实现是根据本地机器相关的。同样我们可以在自己写的类中覆盖hashCode()方法，比如String、Math、Integer、Double…等等这些类都是覆盖了hashCode()方法方法的。

例如在string类中定义的hashCode()方法如下：

public int hashCode() {

int h = hash;

int len = count;

if (h == 0 && len > 0) {

int off = offset;

char val[] = value;

for (int i = 0; i < len; i++) {

h = 31*h + val[off++];

}

hash = h;

}

return h;

}

这里我们首先要明白一个问题：

equals()相等的两个对象，hashCode()一定相等；

equals()不相等的两个对象，却不能证明他们的hashCode()不相等。换句话说，equals()不相等的两个对象，hashCode()有可能相等。（我的理解是由于哈希码在生产的时候产生冲突造成的）。

反过来：hashCode()不相等一定能推出equals()也不相等；hashCode()相等，equals()可能相等也可能不相等。

程序实例：

public class EqualsDemo {

public static void main(String[] args) {

System.out.println("==是比较两个变量的值是否相等！");

Person p1=new Person(1);

Person p2=p1;

System.out.println(p1.hashCode());//12677476System.out.println(p2.hashCode());//12677476System.out.println(p1);//wh.Person@c17164System.out.println(p2);//wh.Person@c17164

System.out.println("p1==p2:"+(p1==p2));//p1==p2:true

Person p3=new Person(1);

System.out.println(p3.hashCode());//33263331System.out.println(p3);//wh.Person@1fb8ee3

System.out.println("p1==p3:"+(p1==p3));//p1==p2:false

//p1和p3引用的对象在逻辑上是同一个

System.out.println("Object.equals()方法用于比较对象是否相等！");

//默认的equals()方法是比较对象的地址！建议覆盖修改！System.out.println("p1.equals(p2):"+p1.equals(p2));//true

System.out.println("p1.equals(p3):"+p1.equals(p3));//false

}

}

class Person{

int id;

String name;

public Person(int id){

this.id=id;

}

}

由上面的实例我们可以看出默认的equals()方法是比较对象的地址！这种比较方法很有局限性，比如：我们判断是否是同一个人是根据一个人的身份证号码（身份证号码可以唯一标识一个人），但是

如果按默认的比较方式，那么两个对象他们的地址不同，就会返回false，但是他们的身份证号码相同，却是同一个人。

再比如：两幅扑克牌，如果花色和点数相等我们就认为这两张牌相等，但这却是两个不同的对象。若是一副牌，我们只需判断点数相等即可认为这两张牌是相等的，而无需判断花色！因此，在现实生活中重写equals()方法是很有必要的，而且SUN公司也建议我们把equals()、hashCode()、toString()等Object类里面的方法重写。可以自己查看API帮助文档！

下面的程序是对equals()、hashCode()改写后的程序！

public class EqualsDemo2 {

public static void main(String[] args) {

//在EqualsDemo类中我们举的例子中p1和p3引用的对象在逻辑上是同一个

System.out.println("Object.equals()方法用于比较对象是否相等！");

//默认的equals()方法是比较对象的地址！建议覆盖修改！//覆盖为根据对象的“关键属性”判断对象是否相等！

Person2 p1=new Person2(1);

Person2 p2=p1;

Person2 p3=new Person2(1);

System.out.println("p1.equals(p2):"+p1.equals(p2));//true

System.out.println("p1.equals(p3):"+p1.equals(p2));//true

}

}

class Person2{

int id;

String name;

public Person2(int id){

this.id=id;

}

/*

* 重写equals()方法，人的身份证不能重复，我们判断是否是同

* 一个人的根据是他们的id(身份证)是否相等！

*/

public boolean equals(Object obj){

//我们必须遵循equals()方法的覆盖（重写）规则

//规则一：任何情况下，x.equals(null)，永远返回falseif(obj==null)

return false;

//规则二：自反性，x.equals(x)必须返回true。

if(this==obj)

return true;

//

if(obj instanceof Person){//相同类型的比较 Person2 other=(Person2)obj;

return this.id==other.id;

}

return false;

}

public int hashCode(){

return id;

}

}