hash算法总结收集

hash算法的意义在于提供了一种快速存取数据的方法,它用一种算法建立键值与真实值之间的对应关系,(每一个真实值只能有一个键值,但是一个键值可以对应多个真实值),这样可以快速在数组等条件中里面存取数据.  
   在网上看了不少HASH资料,所以对HASH的相关资料进行总结和收集。  
  //HashTable.h template class HashTable{ public : HashTable( int count ) ; void put( T* t ,int key ) ; T* get( int key ) ; private : T** tArray ; }  
  //HashTable.cpp template HashTable::HashTable( int count ){ tArray = new T*[count] ;} template void HashTable::put( T* t , int key ){ this->tArray[ key ] = t ;}template T* HashTable::get( int key ) { return this->tArray[ key ] ;}  
  这样,我们只要知道key值,就可以快速存取T类型的数据,而不用像在链表等数据结构中查找一样, 要找来找去的. 至于key值,一般都是用某种算法(所谓的Hash算法)算出来的.例如:字符串的Hash算法, char* value = "hello"; int key = (((((((27* (int)'h'+27)* (int)'e') + 27) * (int)'l') + 27) * (int)'l' +27) * 27 ) + (int)'o' ; Hash函数处理流程Hash,一般翻译做"散列",也有直接音译为"哈希"的,就是把任意长度的输入(又叫做预映射, pre-image),通过散列算法,变换成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意内容的输入转换成相同长度输出的加密方式. 
    
我来做一个比喻吧。  
我们有很多的小猪,每个的体重都不一样,假设体重分布比较平均(我们考虑到公斤级别),我们按照体重来分,划分成100个小猪圈。  
然后把每个小猪,按照体重赶进各自的猪圈里,记录档案。 
好了,如果我们要找某个小猪怎么办呢?我们需要每个猪圈,每个小猪的比对吗?  
当然不需要了。 
我们先看看要找的这个小猪的体重,然后就找到了对应的猪圈了。  
在这个猪圈里的小猪的数量就相对很少了。  
我们在这个猪圈里就可以相对快的找到我们要找到的那个小猪了。 
对应于hash算法。  
就是按照hashcode分配不同的猪圈,将hashcode相同的猪放到一个猪圈里。  
查找的时候,先找到hashcode对应的猪圈,然后在逐个比较里面的小猪。 
所以问题的关键就是建造多少个猪圈比较合适。 
如果每个小猪的体重全部不同(考虑到毫克级别),每个都建一个猪圈,那么我们可以最快速度的找到这头猪。缺点就是,建造那么多猪圈的费用有点太高了。 
如果我们按照10公斤级别进行划分,那么建造的猪圈只有几个吧,那么每个圈里的小猪就很多了。我们虽然可以很快的找到猪圈,但从这个猪圈里逐个确定那头小猪也是很累的。 
所以,好的hashcode,可以根据实际情况,根据具体的需求,在时间成本(更多的猪圈,更快的速度)和空间本(更少的猪圈,更低的空间需求)之间平衡。 
  
Hash算法有很多很多种类。具体的可以参考之前我写的Hash算法的一些分析。本处给大家提供一个集合了很多使用的Hash算法的类,应该可以满足不少人的需要的: 
Java代码  
  
常用的字符串Hash函数还有ELFHash,APHash等等,都是十分简单有效的方法。这些函数使用位运算使得每一个字符都对最后的函数值产生影响。另外还有以MD5和SHA1为代表的杂凑函数,这些函数几乎不可能找到碰撞。

常用字符串哈希函数有BKDRHash,APHash,DJBHash,JSHash,RSHash,SDBMHash,PJWHash,ELFHash等等。对于以上几种哈希函数,我对其进行了一个小小的评测。

Hash函数 数据1 数据2 数据3 数据4 数据1得分 数据2得分 数据3得分 数据4得分 平均分 
BKDRHash 2 0 4774 481 96.55 100 90.95 82.05 92.64 
APHash 2 3 4754 493 96.55 88.46 100 51.28 86.28 
DJBHash 2 2 4975 474 96.55 92.31 0 100 83.43 
JSHash 1 4 4761 506 100 84.62 96.83 17.95 81.94 
RSHash 1 0 4861 505 100 100 51.58 20.51 75.96 
SDBMHash 3 2 4849 504 93.1 92.31 57.01 23.08 72.41 
PJWHash 30 26 4878 513 0 0 43.89 0 21.95 
ELFHash 30 26 4878 513 0 0 43.89 0 21.95

其中数据1为100000个字母和数字组成的随机串哈希冲突个数。数据2为100000个有意义的英文句子哈希冲突个数。数据3为数据1的哈希值与1000003(大素数)求模后存储到线性表中冲突的个数。数据4为数据1的哈希值与10000019(更大素数)求模后存储到线性表中冲突的个数。

经过比较,得出以上平均得分。平均数为平方平均数。可以发现,BKDRHash无论是在实际效果还是编码实现中,效果都是最突出的。APHash也是较为优秀的算法。DJBHash,JSHash,RSHash与SDBMHash各有千秋。PJWHash与ELFHash效果最差,但得分相似,其算法本质是相似的。

在信息修竞赛中,要本着易于编码调试的原则,个人认为BKDRHash是最适合记忆和使用的

C++实现各种hash算法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
#define M  249997
#define M1 1000001
#define M2 0xF0000000
   
// RS Hash Function 
unsigned int RSHash(char*str)
{
    unsigned int b=378551 ;
    unsigned int a=63689 ;
    unsigned int hash=0 ;
       
    while(*str)
    {
        hash=hash*a+(*str++);
        a*=b ;
    }
       
    return(hash % M);
}
   
// JS Hash Function 
unsigned int JSHash(char*str)
{
    unsigned int hash=1315423911 ;
       
    while(*str)
    {
        hash^=((hash<<5)+(*str++)+(hash>>2));
    }
       
    return(hash % M);
}
   
// P. J. Weinberger Hash Function 
unsigned int PJWHash(char*str)
{
    unsigned int BitsInUnignedInt=(unsigned int)(sizeof(unsigned int)*8);
    unsigned int ThreeQuarters=(unsigned int)((BitsInUnignedInt*3)/4);
    unsigned int OneEighth=(unsigned int)(BitsInUnignedInt/8);
    unsigned int HighBits=(unsigned int)(0xFFFFFFFF)<<(BitsInUnignedInt-OneEighth);
    unsigned int hash=0 ;
    unsigned int test=0 ;
       
    while(*str)
    {
        hash=(hash<<OneEighth)+(*str++);
        if((test=hash&HighBits)!=0)
        {
            hash=((hash^(test>>ThreeQuarters))&(~HighBits));
        }
    }
       
    return(hash % M);
}
   
// ELF Hash Function 
unsigned int ELFHash(char*str)
{
    unsigned int hash=0 ;
    unsigned int x=0 ;
       
    while(*str)
    {
        hash=(hash<<4)+(*str++);
        if((x=hash&0xF0000000L)!=0)
        {
            hash^=(x>>24);
            hash&=~x ;
        }
    }
       
    return(hash % M);
}
   
// BKDR Hash Function 
unsigned int BKDRHash(char*str)
{
    unsigned int seed=131 ;// 31 131 1313 13131 131313 etc.. 
    unsigned int hash=0 ;
       
    while(*str)
    {
        hash=hash*seed+(*str++);
    }
       
    return(hash % M);
}
   
// SDBM Hash Function 
unsigned int SDBMHash(char*str)
{
    unsigned int hash=0 ;
       
    while(*str)
    {
        hash=(*str++)+(hash<<6)+(hash<<16)-hash ;
    }
       
    return(hash % M);
}
   
// DJB Hash Function 
unsigned int DJBHash(char*str)
{
    unsigned int hash=5381 ;
       
    while(*str)
    {
        hash+=(hash<<5)+(*str++);
    }
       
    return(hash % M);
}
   
// AP Hash Function 
unsigned int APHash(char*str)
{
    unsigned int hash=0 ;
    int i ;
       
    for(i=0;*str;i++)
    {
        if((i&1)==0)
        {
            hash^=((hash<<7)^(*str++)^(hash>>3));
        }
        else
        {
            hash^=(~((hash<<11)^(*str++)^(hash>>5)));
        }
    }
       
    return(hash % M);
}
   
  
  
/**  
* Hash算法大全<br>  
* 推荐使用FNV1算法  
* @algorithm None  
* @author Goodzzp 2006-11-20  
* @lastEdit Goodzzp 2006-11-20   
* @editDetail Create  
*/ 
public class HashAlgorithms   
{   
/**  
* 加法hash  
* @param key 字符串  
* @param prime 一个质数  
* @return hash结果  
*/ 
public static int additiveHash(String key, int prime)   
{   
   int hash, i;   
   for (hash = key.length(), i = 0; i < key.length(); i++)   
    hash += key.charAt(i);   
   return (hash % prime);   
}   
     
/**  
* 旋转hash  
* @param key 输入字符串  
* @param prime 质数  
* @return hash值  
*/ 
public static int rotatingHash(String key, int prime)   
{   
   int hash, i;   
   for (hash=key.length(), i=0; i<key.length(); ++i)   
     hash = (hash<<4)^(hash>>28)^key.charAt(i);   
   return (hash % prime);   
//   return (hash ^ (hash>>10) ^ (hash>>20));   
}   
     
// 替代:   
// 使用:hash = (hash ^ (hash>>10) ^ (hash>>20)) & mask;   
// 替代:hash %= prime;   
     
     
/**  
* MASK值,随便找一个值,最好是质数  
*/ 
static int M_MASK = 0x8765fed1;   
/**  
* 一次一个hash  
* @param key 输入字符串  
* @return 输出hash值  
*/ 
public static int oneByOneHash(String key)   
{   
   int   hash, i;   
   for (hash=0, i=0; i<key.length(); ++i)   
   {   
     hash += key.charAt(i);   
     hash += (hash << 10);   
     hash ^= (hash >> 6);   
   }   
   hash += (hash << 3);   
   hash ^= (hash >> 11);   
   hash += (hash << 15);   
//   return (hash & M_MASK);   
   return hash;   
}   
     
/**  
* Bernstein's hash  
* @param key 输入字节数组  
* @param level 初始hash常量  
* @return 结果hash  
*/ 
public static int bernstein(String key)   
{   
   int hash = 0;   
   int i;   
   for (i=0; i<key.length(); ++i) hash = 33*hash + key.charAt(i);   
   return hash;   
}   
     
//   
Pearson's Hash   
// char pearson(char[]key, ub4 len, char tab[256])   
// {   
//   char hash;   
//   ub4 i;   
//   for (hash=len, i=0; i<len; ++i)    
//     hash=tab[hash^key[i]];   
//   return (hash);   
// }   
     
CRC Hashing,计算crc,具体代码见其他   
// ub4 crc(char *key, ub4 len, ub4 mask, ub4 tab[256])   
// {   
//   ub4 hash, i;   
//   for (hash=len, i=0; i<len; ++i)   
//     hash = (hash >> 8) ^ tab[(hash & 0xff) ^ key[i]];   
//   return (hash & mask);   
// }   
     
/**  
* Universal Hashing  
*/ 
public static int universal(char[]key, int mask, int[] tab)   
{   
   int hash = key.length, i, len = key.length;   
   for (i=0; i<(len<<3); i+=8)   
   {   
     char k = key[i>>3];   
     if ((k&0x01) == 0) hash ^= tab[i+0];   
     if ((k&0x02) == 0) hash ^= tab[i+1];   
     if ((k&0x04) == 0) hash ^= tab[i+2];   
     if ((k&0x08) == 0) hash ^= tab[i+3];   
     if ((k&0x10) == 0) hash ^= tab[i+4];   
     if ((k&0x20) == 0) hash ^= tab[i+5];   
     if ((k&0x40) == 0) hash ^= tab[i+6];   
     if ((k&0x80) == 0) hash ^= tab[i+7];   
   }   
   return (hash & mask);   
}   
     
/**  
* Zobrist Hashing  
*/   
public static int zobrist( char[] key,int mask, int[][] tab)   
{   
   int hash, i;   
   for (hash=key.length, i=0; i<key.length; ++i)   
     hash ^= tab[i][key[i]];   
   return (hash & mask);   
}   
     
// LOOKUP3    
// 见Bob Jenkins(3).c文件   
     
// 32位FNV算法   
static int M_SHIFT = 0;   
/**  
* 32位的FNV算法  
* @param data 数组  
* @return int值  
*/ 
    public static int FNVHash(byte[] data)   
    {   
        int hash = (int)2166136261L;   
        for(byte b : data)   
            hash = (hash * 16777619) ^ b;   
        if (M_SHIFT == 0)   
            return hash;   
        return (hash ^ (hash >> M_SHIFT)) & M_MASK;   
    }   
    /**  
     * 改进的32位FNV算法1  
     * @param data 数组  
     * @return int值  
     */ 
    public static int FNVHash1(byte[] data)   
    {   
        final int p = 16777619;   
        int hash = (int)2166136261L;   
        for(byte b:data)   
            hash = (hash ^ b) * p;   
        hash += hash << 13;   
        hash ^= hash >> 7;   
        hash += hash << 3;   
        hash ^= hash >> 17;   
        hash += hash << 5;   
        return hash;   
    }   
    /**  
     * 改进的32位FNV算法1  
     * @param data 字符串  
     * @return int值  
     */ 
    public static int FNVHash1(String data)   
    {   
        final int p = 16777619;   
        int hash = (int)2166136261L;   
        for(int i=0;i<data.length();i++)   
            hash = (hash ^ data.charAt(i)) * p;   
        hash += hash << 13;   
        hash ^= hash >> 7;   
        hash += hash << 3;   
        hash ^= hash >> 17;   
        hash += hash << 5;   
        return hash;   
    }   
     
    /**  
     * Thomas Wang的算法,整数hash  
     */   
    public static int intHash(int key)   
    {   
      key += ~(key << 15);   
      key ^= (key >>> 10);   
      key += (key << 3);   
      key ^= (key >>> 6);   
      key += ~(key << 11);   
      key ^= (key >>> 16);   
      return key;   
    }   
    /**  
     * RS算法hash  
     * @param str 字符串  
     */ 
    public static int RSHash(String str)   
    {   
        int b    = 378551;   
        int a    = 63689;   
        int hash = 0;   
     
       for(int i = 0; i < str.length(); i++)   
       {   
          hash = hash * a + str.charAt(i);   
          a    = a * b;   
       }   
     
       return (hash & 0x7FFFFFFF);   
    }   
    /* End Of RS Hash Function */ 
     
    /**  
     * JS算法  
     */ 
    public static int JSHash(String str)   
    {   
       int hash = 1315423911;   
     
       for(int i = 0; i < str.length(); i++)   
       {   
          hash ^= ((hash << 5) + str.charAt(i) + (hash >> 2));   
       }   
     
       return (hash & 0x7FFFFFFF);   
    }   
    /* End Of JS Hash Function */ 
     
    /**  
     * PJW算法  
     */ 
    public static int PJWHash(String str)   
    {   
        int BitsInUnsignedInt = 32;   
        int ThreeQuarters     = (BitsInUnsignedInt * 3) / 4;   
        int OneEighth         = BitsInUnsignedInt / 8;   
        int HighBits          = 0xFFFFFFFF << (BitsInUnsignedInt - OneEighth);   
        int hash              = 0;   
        int test              = 0;   
     
       for(int i = 0; i < str.length();i++)   
       {   
          hash = (hash << OneEighth) + str.charAt(i);   
     
          if((test = hash & HighBits) != 0)   
          {   
             hash = (( hash ^ (test >> ThreeQuarters)) & (~HighBits));   
          }   
       }   
     
       return (hash & 0x7FFFFFFF);   
    }   
    /* End Of P. J. Weinberger Hash Function */ 
     
    /**  
     * ELF算法  
     */ 
    public static int ELFHash(String str)   
    {   
        int hash = 0;   
        int x    = 0;   
     
       for(int i = 0; i < str.length(); i++)   
       {   
          hash = (hash << 4) + str.charAt(i);   
          if((x = (int)(hash & 0xF0000000L)) != 0)   
          {   
             hash ^= (x >> 24);   
             hash &= ~x;   
          }   
       }   
     
       return (hash & 0x7FFFFFFF);   
    }   
    /* End Of ELF Hash Function */ 
     
    /**  
     * BKDR算法  
     */ 
    public static int BKDRHash(String str)   
    {   
        int seed = 131; // 31 131 1313 13131 131313 etc..   
        int hash = 0;   
     
       for(int i = 0; i < str.length(); i++)   
       {   
          hash = (hash * seed) + str.charAt(i);   
       }   
     
       return (hash & 0x7FFFFFFF);   
    }   
    /* End Of BKDR Hash Function */ 
     
    /**  
     * SDBM算法  
     */ 
    public static int SDBMHash(String str)   
    {   
        int hash = 0;   
     
       for(int i = 0; i < str.length(); i++)   
       {   
          hash = str.charAt(i) + (hash << 6) + (hash << 16) - hash;   
       }   
     
       return (hash & 0x7FFFFFFF);   
    }   
    /* End Of SDBM Hash Function */ 
     
    /**  
     * DJB算法  
     */ 
    public static int DJBHash(String str)   
    {   
       int hash = 5381;   
     
       for(int i = 0; i < str.length(); i++)   
       {   
          hash = ((hash << 5) + hash) + str.charAt(i);   
       }   
     
       return (hash & 0x7FFFFFFF);   
    }   
    /* End Of DJB Hash Function */ 
     
    /**  
     * DEK算法  
     */ 
    public static int DEKHash(String str)   
    {   
        int hash = str.length();   
     
       for(int i = 0; i < str.length(); i++)   
       {   
          hash = ((hash << 5) ^ (hash >> 27)) ^ str.charAt(i);   
       }   
     
       return (hash & 0x7FFFFFFF);   
    }   
    /* End Of DEK Hash Function */ 
     
    /**  
     * AP算法  
     */ 
    public static int APHash(String str)   
    {   
        int hash = 0;   
     
       for(int i = 0; i < str.length(); i++)   
       {   
          hash ^= ((i & 1) == 0) ? ( (hash << 7) ^ str.charAt(i) ^ (hash >> 3)) :   
                                   (~((hash << 11) ^ str.charAt(i) ^ (hash >> 5)));   
       }   
     
//       return (hash & 0x7FFFFFFF);   
       return hash;   
    }   
    /* End Of AP Hash Function */ 
          
    /**  
     * JAVA自己带的算法  
     */ 
    public static int java(String str)   
{   
   int h = 0;   
   int off = 0;   
   int len = str.length();   
   for (int i = 0; i < len; i++)   
   {   
    h = 31 * h + str.charAt(off++);   
   }   
   return h;   
}   
          
    /**  
     * 混合hash算法,输出64位的值  
     */ 
      public static long mixHash(String str)   
     {   
    long hash = str.hashCode();   
     hash <<= 32;   
     hash |= FNVHash1(str);   
    return hash;   
     }

  

[原文转自:http://my.oschina.net/u/2007546/blog/425681]

hash算法总结收集相关推荐

  1. 一致性 hash 算法( consistent hashing )

    原文地址:http://blog.csdn.net/sparkliang/article/details/5279393 consistent hashing 算法早在 1997 年就在论文 Cons ...

  2. 区块链笔记-Hash算法

    链客,专为开发者而生,有问必答! 此文章来自区块链技术社区,未经允许拒绝转载. 区块链笔记-Hash算法 区块链技术是一系列技术的结合,建立新的技术架构,hash算法是很重要的一块,如果理解不当的地方 ...

  3. 区块链概念:Hash 算法

    链客,专为开发者而生,有问必答! 此文章来自链客区块链技术问答社区,未经允许拒绝转载. 区块链概念1:Hash 算法 作用在学习哈希算法前,我们需要知道哈希在区块链的作用哈希算法的作用如下:区块链通过 ...

  4. 一致性 Hash 算法的实际应用

    前言 记得一年前分享过一篇<一致性 Hash 算法分析>,当时只是分析了这个算法的实现原理.解决了什么问题等. 但没有实际实现一个这样的算法,毕竟要加深印象还得自己撸一遍,于是本次就当前的 ...

  5. 不会一致性hash算法,劝你简历别写搞过负载均衡

    这两天看到技术群里,有小伙伴在讨论一致性hash算法的问题,正愁没啥写的题目就来了,那就简单介绍下它的原理.下边我们以分布式缓存中经典场景举例,面试中也是经常提及的一些话题,看看什么是一致性hash算 ...

  6. 用人话理解hash算法、特性、唯一性等

    背景 博主在本科的时候曾经参加过数学建模,当初提交参赛论文的时候有两个提交时间点,第一个是提交MD5码的时间,第二个是提交具体参赛论文的时间,当初就很纳闷,直接提交论文不就ok吗?为什么多此一举呢 我 ...

  7. 什么是一致性 Hash 算法

    数据分片 先让我们看一个例子吧 我们经常会用 Redis 做缓存,把一些数据放在上面,以减少数据的压力. 当数据量少,访问压力不大的时候,通常一台Redis就能搞定,为了高可用,弄个主从也就足够了: ...

  8. hash算法_一致性hash算法简介

    一致性hash算法有什么用?我们为什么需要一致性hash算法?这两个问题的答案可以看这篇文章 分布式系统路由算法简介. 了解了一致性hash算法出现的背景,我们来看看什么是一致性hash算法.一致性h ...

  9. 一致性Hash算法(KetamaHash)的c#实现

    Consistent Hashing最大限度地抑制了hash键的重新分布.另外要取得比较好的负载均衡的效果,往往在服务器数量比较少的时候需要增加虚拟节点来保证服务器能均匀的分布在圆环上.因为使用一般的 ...

  10. MurmurHash算法:高运算性能,低碰撞率的hash算法

    MurmurHash算法:高运算性能,低碰撞率,由Austin Appleby创建于2008年,现已应用到Hadoop.libstdc++.nginx.libmemcached等开源系统.2011年A ...

最新文章

  1. 西门子smart200以太网通讯协议
  2. 硬件数据手册中如何表示信号高低电平有效?
  3. web服务器配置(静态页面)
  4. 富人为什么会富,穷人为什么穷?看完你就懂
  5. hadoop 分片与分块,map task和reduce task的理解
  6. ASP.NET使用管道模型(PipleLines)处理HTTP请求
  7. 从零开始学视觉Transformer (7):Swin Transformer-2
  8. php 动态图表,excel实现动态图表的3种方法是什么
  9. 全球加密货币总市值突破7500亿美元 比特币市值突破5200亿美元
  10. 存储引擎和Mysql服务层出现索引信息不一致错误提示
  11. java创建对象实例的四种方式
  12. IDEA插件jrebel的配置使用
  13. iOS视图成像理论及性能优化
  14. YOLOV5:在本地电脑训练模型
  15. 一文教你如何快速实现声音识别
  16. 一些恶搞人的C++程序(千万别试,会哭的)
  17. the android sdk location cannot be at the filesystem root. 问题解决
  18. NICEGUI---ROS开发之中常用的GUI工具
  19. Hello Spring boot
  20. Retrofit图片上传及进度的显示

热门文章

  1. 一个传统的前端框架的布局
  2. VM安装CentOS6-相关NAT上网VM-tools安装
  3. 编码解码UNICODE
  4. Web Service(二):cxf 实现
  5. Android新组件CardView
  6. weblogic 找不到数据源问题
  7. 开发板ping不通Linux虚拟机的原因及解决办法
  8. FRM-92120: Registry.dat
  9. IE打开xml文件弹出下载对话框
  10. 拓端tecdat|R语言结合新冠疫情COVID-19对股票价格预测:ARIMA,KNN和神经网络时间序列分析