当前位置：首页 » 编程语言 » java哈希算法

java哈希算法

发布时间: 2021-01-14 06:08:33

A. java有没有不会冲突的hash算法

java.util.HashMap的中put方法的具体实现：
static inline intptr_t get_next_hash(Thread * Self, oop obj) {
intptr_t value = 0 ;
if (hashCode == 0) {
// This form uses an unguarded global Park-Miller RNG,
// so it's possible for two threads to race and generate the same RNG.
// On MP system we'll have lots of RW access to a global, so the
// mechanism inces lots of coherency traffic.
value = os::random() ;
} else
if (hashCode == 1) {
// This variation has the property of being stable (idempotent)
// between STW operations. This can be useful in some of the 1-0
// synchronization schemes.
intptr_t addrBits = intptr_t(obj) >> 3 ;
value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom ;
} else
if (hashCode == 2) {
value = 1 ; // for sensitivity testing
} else
if (hashCode == 3) {
value = ++GVars.hcSequence ;
} else
if (hashCode == 4) {
value = intptr_t(obj) ;
} else {
// Marsaglia's xor-shift scheme with thread-specific state
// This is probably the best overall implementation -- we'll
// likely make this the default in future releases.
unsigned t = Self->_hashStateX ;
t ^= (t << 11) ;
Self->_hashStateX = Self->_hashStateY ;
Self->_hashStateY = Self->_hashStateZ ;
Self->_hashStateZ = Self->_hashStateW ;
unsigned v = Self->_hashStateW ;
v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ;
Self->_hashStateW = v ;
value = v ;
}

value &= markOopDesc::hash_mask;
if (value == 0) value = 0xBAD ;
assert (value != markOopDesc::no_hash, "invariant") ;
TEVENT (hashCode: GENERATE) ;
return value;
}

该实现位于hotspot/src/share/vm/runtime/synchronizer.cpp文件下。

B. Java语言中Object对象的hashCode取值的底层算法是怎样实现的

在JDK中看到

public native int hashCode();

这是一个本地方法，需要找源代码才能找到

然后我在Android SDK中的JDK Object类找到了这个，应该是你想要的了

publicinthashCode(){
intlockWord=shadow$_monitor_;
finalintlockWordStateMask=0xC0000000;//Top2bits.
finalintlockWordStateHash=0x80000000;//Top2bitsarevalue2(kStateHash).
finalintlockWordHashMask=0x0FFFFFFF;//Low28bits.
if((lockWord&lockWordStateMask)==lockWordStateHash){
returnlockWord&lockWordHashMask;
}
returnSystem.identityHashCode(this);
}

但最后的System.identityHashCode(this)方法还是一个本地方法，还得去找源码，你折腾的话自己去搜索吧。

下面是String类的hashCode()方法，可以看下

publicinthashCode(){
inth=hash;
if(h==0&&value.length>0){
charval[]=value;

for(inti=0;i<value.length;i++){
h=31*h+val[i];
}
hash=h;
}
returnh;
}

C. java中哪些地方实现了一致性hash算法

关于一致性Hash算法，在我之前的博文中已经有多次提到了，MemCache超详细解读一文中"一致性Hash算法"部分，对于为什么要使用一致性Hash算法、一致性Hash算法的算法原理做了详细的解读。

算法的具体原理这里再次贴上：

先构造一个长度为232的整数环（这个环被称为一致性Hash环），根据节点名称的Hash值（其分布为[0, 232-1]）将服务器节点放置在这个Hash环上，然后根据数据的Key值计算得到其Hash值（其分布也为[0, 232-1]），接着在Hash环上顺时针查找距离这个Key值的Hash值最近的服务器节点，完成Key到服务器的映射查找。

这种算法解决了普通余数Hash算法伸缩性差的问题，可以保证在上线、下线服务器的情况下尽量有多的请求命中原来路由到的服务器。

当然，万事不可能十全十美，一致性Hash算法比普通的余数Hash算法更具有伸缩性，但是同时其算法实现也更为复杂，本文就来研究一下，如何利用Java代码实现一致性Hash算法。在开始之前，先对一致性Hash算法中的几个核心问题进行一些探究。

D. java小问题，使用哈希表储存元素(比如说字符串)，我们老师是把哈希表比作一个数组，然后通过算法计

哈希表要占用抄比成员数据略大的袭连续地址空间。比如你存10个数，可能需要申请20个数的地址空间a[20].
散列函数把这10个数分别散落在这20个空间中，好的散列函数生成的地址值需要没有碰撞冲突，2个数据出现在一个地址空间的机率要最小化...

E. 怎样比较深刻的理解Java中各种算法结构及实现原理，例如HashMap中用到的Hash算法

你这打击面实在太大了真的没法和你说
算法这东西本质上就是数学想要提供算法能力方法只有一个就是提高自己的数学能力其他就是假的

F. java 1.哈希算法的实现：输出这组数据

public static void main(String[] args){
System.out.println("输入n，按回复车：");
Scanner s = new Scanner(System.in);
Integer n = Integer.parseInt(s.next());
Integer re = factorial(1, n);
System.out.println(re);
}
public static Integer factorial(Integer a, Integer b){
if(b == 1){
return a * b;
}else{
return a * b * factorial(a, b-1);
}
}
量，制当温度降低时，物体内能减小。所有能量的单位都是：焦耳。热

G. Java HashMap的get(),put()算法时间复杂度

最优情况，hash不碰撞，O(1)，典型情况，近似是O(1)，因为几乎没有碰撞，最坏情况，O(N)，也就是所有的hash都一样，那么退化为线性查找

H. java 1.哈希算法的实现：

public class Test { /*创建类*/

public static void main(String[] args) {
System.out.println(dg(100));
}

static int dg(int i) { /*定义变量复 */
int sum;
if (i == 1) /*假设制条件*/
return 1;
else
sum = i + dg(i - 1); /*1~100的和的表达式*/
return sum; /*返回结果*/
}
}
这个脚本语言为 Internet 应用而生，它可以看作是 Haskell 和 Java 的结合。

I. Java中单向散列函数算法

Hash，一般翻译做“散列”，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。

数学表述为：h = H(M) ，其中H( )--单向散列函数，M--任意长度明文，h--固定长度散列值。

在信息安全领域中应用的Hash算法，还需要满足其他关键特性：

第一当然是单向性(one-way)，从预映射，能够简单迅速的得到散列值，而在计算上不可能构造一个预映射，使其散列结果等于某个特定的散列值，即构造相应的M=H-1(h)不可行。这样，散列值就能在统计上唯一的表征输入值，因此，密码学上的 Hash 又被称为"消息摘要(message digest)"，就是要求能方便的将"消息"进行"摘要"，但在"摘要"中无法得到比"摘要"本身更多的关于"消息"的信息。

第二是抗冲突性(collision-resistant)，即在统计上无法产生2个散列值相同的预映射。给定M，计算上无法找到M'，满足H(M)=H(M') ，此谓弱抗冲突性；计算上也难以寻找一对任意的M和M'，使满足H(M)=H(M') ，此谓强抗冲突性。要求"强抗冲突性"主要是为了防范所谓"生日攻击(birthday attack)"，在一个10人的团体中，你能找到和你生日相同的人的概率是2.4%，而在同一团体中，有2人生日相同的概率是11.7%。类似的，当预映射的空间很大的情况下，算法必须有足够的强度来保证不能轻易找到"相同生日"的人。

第三是映射分布均匀性和差分分布均匀性，散列结果中，为 0 的 bit 和为 1 的 bit ，其总数应该大致相等；输入中一个 bit 的变化，散列结果中将有一半以上的 bit 改变，这又叫做"雪崩效应(avalanche effect)"；要实现使散列结果中出现 1bit 的变化，则输入中至少有一半以上的 bit 必须发生变化。其实质是必须使输入中每一个 bit 的信息，尽量均匀的反映到输出的每一个 bit 上去；输出中的每一个 bit，都是输入中尽可能多 bit 的信息一起作用的结果。

J. Java hashMap合并算法

用Kotlin语言写了一下，Java只要把MutableMap改成Map就可以了

importkotlin.random.Random;
funmain(arg:Array<String>){
	println("HelloWorld");
	valmap:Map<String,String>=hashMapOf(
		"1242"to"A31_001","2424"to"A31_001",
		"3646"to"A31_002");
	println("原map:$map");
	valgroups:HashMap<String,MutableMap<String,String>>=hashMapOf();
	for((k,v)inmap.entries){
		if(!groups.containsKey(v))groups.put(v,hashMapOf());		
		valm=groups.getValue(v);
		m.put(k,v);
	}
	println("重组新map:$groups");
	//给换成新随机id,没必要但为满足要求
	valnewMap:HashMap<Int,MutableMap<String,String>>=hashMapOf();
	varid:Int;	
	for(vingroups.values){		
		do{id=Random.nextInt();}
		while(newMap.containsKey(id));
		newMap.put(id,v);
	}
	println("新随机生成ID:$newMap");
}

html">
>Task:run
HelloWorld
原map:{1242=A31_001,3646=A31_002,2424=A31_001}
重组新map:{A31_002={3646=A31_002},A31_001={2424=A31_001,1242=A31_001}}
新随机生成ID:{-91779881={2424=A31_001,1242=A31_001},2102779363={3646=A31_002}}

BUILDSUCCESSFULin0s

阅读全文

java哈希算法

与java哈希算法相关的阅读推荐