hashcode长度

hash code是什么

哈希码，你可以看做一个对象的身份证，主要作用是用来比对对象是否相同。

但要注意，在一个较大的范围内，两个对象的哈希码有可能相同。

哈希码的长度是固定大小的，试想在将无限多的对象生成哈希码，必然会有重复的哈希码值。就像MD5一样。

介绍hashCode

大家一定要遵守。

2.

其次是

hashcode()

方法，在

object

类中定义如下：

public native int hashCode(); 。

说明是一个本地方法，

它的实现是根据本地机器相关的。

当然我们可以在自己写的类中覆盖。

hashcode()

方法，比如

String

、

Integer

、

Double

。

。

。

。等等这些类都是覆盖了

hashcode()

方法的。例如在

String

类中定义的

hashcode()

方法如下：

public int hashCode() { 。

int h = hash; 。

if (h == 0) { 。

int off = offset; 。

char val[] = value; 。

int len = count; 。

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

。

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

}

hash = h;

}

return h;

}

解释一下这个程序（

String

的

API

中写到）

：

s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 。

使用

int

算法，这里

s[i]

是字符串的第

i

个字符，

n

是字符串的长度，

^

表示求幂。

（空

字符串的哈希码为

。

）

3.

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

equals()

相等的两个对象，

hashcode()

一定相等；

equals

（）

不相等的两个对象，

却并不能证明他们的

hashcode()

不相等。

换句话说，

equals()

方法不相等的两个对象，

hashcode()

有可能相等。

（我的理解是由于哈希码在生成的时候产。

生冲突造成的）

。

反过来：

hashcode()

不等，一定能推出

equals()

也不等；

hashcode()

相等，

equals()

可能相

等，

也可能不等。

解释下第

点的使用范围，

我的理解是在

object

、

String

等类中都能使用。

在

object

类中，

hashcode()

方法是本地方法，返回的是对象的地址值，而。

object

类中的

equals()

方法比较的也是两个对象的地址值，如果。

equals()

相等，说明两个对象地址值也相

等，当然

hashcode()

也就相等了；在

String

类中，

equals()

返回的是两个对象内容的比较，

当两个对象内容相等时，

Hashcode()

方法根据

String

类的重写（第

点里面已经分析了）代码的分析，也可知道。

hashcode()

返回结果也会相等。以此类推，可以知道。

Integer

、

Double

等封装类中经过重写

的

equals()

和

hashcode()

方法也同样适合于这个原则。当然没有经过重写的类，在继承了。

object

类的

equals()

和

hashcode()

方法后，也会遵守这个原则。

4.

谈到

hashcode()

和

equals()

就不能不说到

hashset,hashmap,hashtable。

中的使用，

具体是

怎样呢，请看如下分析：

Hashset

是继承

Set

接口，

Set

接口又实现

Collection

接口，这是层次关系。那么

hashset

是根据什么原理来存取对象的呢？

在

hashset

中不允许出现重复对象，

元素的位置也是不确定的。

在

hashset

中又是怎样判定

元素是否重复的呢？这就是问题的关键所在，经过一下午的查询求证终于获得了一点启示，

和大家分享一下，在

java

的集合中，判断两个对象是否相等的规则是：

1)

，判断两个对象的

hashCode

是否相等

如果不相等，认为两个对象也不相等，完毕。

如果相等，转入

2)

（这一点只是为了提高存储效率而要求的，

其实理论上没有也可以，

但如果没有，

实际使用

时效率会大大降低，所以我们这里将其做为必需的。后面会重点讲到这个问题。

）

2)

，判断两个对象用

equals

运算是否相等

如果不相等，认为两个对象也不相等。

如果相等，认为两个对象相等（

equals()

是判断两个对象是否相等的关键）

为什么是两条准则，难道用第一条不行吗？不行，因为前面已经说了，

hashcode()

相等时，

equals()

方法也可能不等，

所以必须用第

条准则进行限制，

才能保证加入的为非重复元素。

比如下面的代码：

public static void main(String args[]){ 。

String s1=new String("zhaoxudong"); 。

String s2=new String("zhaoxudong"); 。

System.out.println(s1==s2);//false 。

System.out.println(s1.equals(s2));//true 。

System.out.println(s1.hashCode());//s1.hashcode()。

等于

s2.hashcode() 。

System.out.println(s2.hashCode()); 。

Set hashset=new HashSet(); 。

hashset.add(s1); 。

hashset.add(s2); 。

/*

实质上在添加

s1,s2

时，运用上面说到的两点准则，可以知道。

hashset

认为

s1

和

s2

是相

等的，是在添加重复元素，所以让。

s2

覆盖了

s1;*/

Iterator it=hashset.iterator(); 。

while(it.hasNext()) 。

{

System.out.println(it.next()); 。

}

最后在

while

循环的时候只打印出了一个

”zhaoxudong”

。

输出结果为：

false

true

-967303459

-967303459

这是因为

String

类已经重写了

equals()

方法和

hashcode()

方法，所以在根据上面的第

1.2

条原则判定时，

hashset

认为它们是相等的对象，进行了重复添加。

但是看下面的程序：

import java.util.*; 。

public class HashSetTest 。

{

public static void main(String[] args) 。

{

。

HashSet hs=new HashSet(); 。

。

hs.add(new Student(1,"zhangsan")); 。

。

hs.add(new Student(2,"lisi")); 。

。

hs.add(new Student(3,"wangwu")); 。

。

hs.add(new Student(1,"zhangsan")); 。

Iterator it=hs.iterator(); 。

。

while(it.hasNext()) 。

。

{

。

System.out.println(it.next()); 。

。

}

}

}

class Student 。

{

int num;

String name;

Student(int num,String name) 。

。

{

。

this.num=num; 。

。

this.name=name; 。

。

}

public String toString() 。

。

{

。

return num+":"+name; 。

。

}

}

输出结果为：

1:zhangsan

。

1:zhangsan

。

3:wangwu

。

2:lisi

问题出现了，

为什么

hashset

添加了相等的元素呢，

这是不是和

hashset

的原则违背了呢？

回答是：没有

因为在根据

hashcode()

对两次建立的

new Student(1,"zhangsan")。

对象进行比较时，生成的

是不同的哈希码值，

所以

hashset

把他当作不同的对象对待了，

当然此时的

equals()

方法返

回的值也不等（这个不用解释了吧）

。那么为什么会生成不同的哈希码值呢？上面我们在比。

较

s1

和

s2

的时候不是生成了同样的哈希码吗？原因就在于我们自己写的。

Student

类并没有

重新自己的

hashcode()

和

equals()

方法，

所以在比较时，

是继承的

object

类中的

hashcode()

方法，呵呵，各位还记得

object

类中的

hashcode()

方法比较的是什么吧！

！

它是一个本地方法，比较的是对象的地址（引用地址）

，使用

new

方法创建对象，两次生成

的当然是不同的对象了

（这个大家都能理解吧。

。

。

）

，

造成的结果就是两个对象的

hashcode()

返回的值不一样。所以根据第一个准则，

hashset

会把它们当作不同的对象对待，自然也用。

不着第二个准则进行判定了。那么怎么解决这个问题呢？？

答案是：在

Student

类中重新

hashcode()

和

equals()

方法。

例如：

class Student 。

{

int num;

String name;

Student(int num,String name) 。

{

this.num=num; 。

this.name=name; 。

}

public int hashCode() 。

{

return num*name.hashCode(); 。

}

public boolean equals(Object o) 。

{

Student s=(Student)o; 。

return num==s.num && name.equals(s.name); 。

}

public String toString() 。

{

return num+":"+name; 。

}

}

根据重写的方法，即便两次调用了。

new

Student(1,"zhangsan")。

，我们在获得对象的哈希码

时，

根据重写的方法

hashcode()

，获得的哈希码肯定是一样的

（这一点应该没有疑问吧）

。

当然根据

equals()

方法我们也可判断是相同的。

所以在向

hashset

集合中添加时把它们当作

重复元素看待了。所以运行修改后的程序时，我们会发现运行结果是：

1:zhangsan

。

3:wangwu

。

2:lisi

可以看到重复元素的问题已经消除。

关于在

hibernate

的

pojo

类中，重新

equals()

和

hashcode()

的问题：

1)

，重点是

equals

，重写

hashCode

只是技术要求（为了提高效率）

2)

，为什么要重写

equals

呢，因为在

java

的集合框架中，是通过

equals

来判断两个对象

是否相等的

3)

，在

hibernate

中，经常使用

set

集合来保存相关对象，而

set

集合是不允许重复的。我

们再来谈谈前面提到在向

hashset

集合中添加元素时

怎样判断对象是否相同的准则，前面。

说了两条，其实只要重写

equals()

这一条也可以。

但当

hashset

中元素比较多时，或者是重写的

equals()

方法比较复杂时，我们只用

equals()

方法进行比较判断，效率也会非常低，所以引入了。

hashcode()

这个方法，只是为了提高效

率，

但是我觉得这是非常有必要的

（所以我们在前面以两条准则来进行。

hashset

的元素是否

重复的判断）

。

比如可以这样写：

public int hashCode(){ 。

return

1;}//

等价于

hashcode

无效

这样做的效果就是在比较哈希码的时候不能进行判断，因为每个对象返回的哈希码都是。

，

每次都必须要经过比较

equals()

方法后才能进行判断是否重复，

这当然会引起效率的大大降

低。

我有一个问题，如果像前面提到的在。

hashset

中判断元素是否重复的必要方法是。

equals()

方法（根据网上找到的观点）

，但是这里并没有涉及到关于哈希表的问题，可是这个集合却。

叫

hashset

，这是为什么？？

我想，在

hashmap,hashtable。

中的存储操作，依然遵守上面的准则。所以这里不再多说。

这些是今天看书，网上查询资料，自己总结出来的，部分代码和语言是引述，但是千真万确。

是自己总结出来的。

有错误之处和不详细不清楚的地方还请大家指出，

我也是初学者，

所以

难免会有错误的地方，希望大家共同讨论。

http://wenku.baidu.com/view/75b5560fde80d4d8d15a4ff6.html。

java:String.hashcode可以保证多长的字符串的值唯一

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。

散列函数能使对一个数据序列的访问过程更加迅速有效，通过散列函数，数据元素将被更快地定位。

实际工作中需视不同的情况采用不同的哈希函数，通常考虑的因素有：

· 计算哈希函数所需时间

· 关键字的长度

· 哈希表的大小

· 关键字的分布情况

· 记录的查找频率

1. 直接寻址法：取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a·key + b，其中a和b为常数（这种散列函数叫做自身函数）。若其中H(key）中已经有值了，就往下一个找，直到H(key）中没有值了，就放进去。

2. 数字分析法：分析一组数据，比如一组员工的出生年月日，这时我们发现出生年月日的前几位数字大体相同，这样的话，出现冲突的几率就会很大，但是我们发现年月日的后几位表示月份和具体日期的数字差别很大，如果用后面的数字来构成散列地址，则冲突的几率会明显降低。因此数字分析法就是找出数字的规律，尽可能利用这些数据来构造冲突几率较低的散列地址。

3. 平方取中法：取关键字平方后的中间几位作为散列地址。

4. 折叠法：将关键字分割成位数相同的几部分，最后一部分位数可以不同，然后取这几部分的叠加和（去除进位）作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。移位叠加是将分割后的每一部分的最低位对齐，然后相加；间界叠加是从一端向另一端沿分割界来回折叠，然后对齐相加。

5. 随机数法：选择一随机函数，取关键字的随机值作为散列地址，通常用于关键字长度不同的场合。

6. 除留余数法：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p,p<=m。不仅可以对关键字直接取模，也可在折叠、平方取中等运算之后取模。对p的选择很重要，一般取素数或m，若p选的不好，容易产生同义词。

中文hashcode的范围

java 1.7源码中，java.lang.String.hashCode()注释如下：

Returns a hash code for this string. The hash code for a String object is computed as。

 s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 。

using int arithmetic, where s[i] is the ith character of the string, n is the length of the 。

string, and ^ indicates exponentiation. (The hash value of the 。

empty string is zero.)。

具体使用可以参考 浅谈Java中的hashcode方法。

Java中的HashCode问题

极端情况下会有大量的对象产生一个相同的索引.这就是关系Hashtable性能问题的最重要的问题: Hash冲突。 常见的Hash冲突是不同key对象最终产生了相同的索引，而一种非常甚至绝对少见的Hash冲突是，如果一组对象的个数大过了 int范围，而HashCode的长度只能在int范围中，所以肯定要有同一组的元素有相同的HashCode，这样无论如何他们都会有相同的索引.当然这种极端的情况是极少见的，可以暂不考虑，但是对于同的HashCode经过取模，则会产中相同的索引，或者不同的对象却具有相同的HashCode，当然具有相同的索引。

原文地址：http://www.qianchusai.com/hashcode%E9%95%BF%E5%BA%A6.html