本站提倡有节制游戏,合理安排游戏时间,注意劳逸结合。

【小说源码源码】【jingle html 源码解析】【虚拟环绕系统源码】hash实现源码

2024-11-30 05:51:22 来源:休闲 分类:休闲

1.急求LZW算法源代码!!!
2.concurrenthashmap1.8源码如何详细解析?实现
3.String源码分析(1)--哈希篇
4.如何安全地存储密码
5.HashMap实现原理
6.深入理解 HashSet 及底层源码分析

hash实现源码

急求LZW算法源代码!!!

       #include<iostream>

       #include<cstdio>

       #include<cstring>

       #include<ctime>//用来计算压缩的时间

       using namespace std;

       //定义常数

       const int MAX = ;//最大code数,是源码一个素数,求模是实现速度比较快

       const int ascii = ; //ascii代码的数量

       const int ByteSize = 8; //8个字节

       struct Element//hash表中的元素

       {

        int key;

        int code;

        Element *next;

       }*table[MAX];//hash表

       int hashfunction(int key)//hash函数

       {

        return key%MAX;

       }

       void hashinit(void)//hash表初始化

       {

        memset(table,0,sizeof(table));

       }

       void hashinsert(Element element)//hash表的插入

       {

        int k = hashfunction(element.key);

        if(table[k]!=NULL)

        {

        Element *e=table[k];

        while(e->next!=NULL)

        {

        e=e->next;

        }

        e->next=new Element;

        e=e->next;

        e->key = element.key;

        e->code = element.code;

        e->next = NULL;

        }

        else

        {

        table[k]=new Element;

        table[k]->key = element.key;

        table[k]->code = element.code;

        table[k]->next = NULL;

        }

       }

       bool hashfind(int key,Element &element)//hash表的查找

       {

        int k = hashfunction(key);

        if(table[k]!=NULL)

        {

        Element *e=table[k];

        while(e!=NULL)

        {

        if(e->key == key)

        {

        element.key = e->key;

        element.code = e->code;

        return true;

        }

        e=e->next;

        }

        return false;

        }

        else

        {

        return false;

        }

       }

       void compress(void)//压缩程序

       {

        //打开一个流供写入

        FILE *fp;

        fp = fopen("result.dat", "wb");

        Element element;

        int used;

        char c;

        int pcode, k;

        for(int i=0;i<ascii;i++)

        {

        element.key = i;

        element.code = i;

        hashinsert(element);

        }

        used = ascii;

        c = getchar();

        pcode = c;

        while((c = getchar()) != EOF)

        {

        k = (pcode << ByteSize) + c;

        if(hashfind(k, element))

        pcode = element.code;

        else

        {

        //cout<<pcode<<' ';

        fwrite(&pcode, sizeof(pcode), 1, fp);

        element.code = used++;

        element.key = (pcode << ByteSize) | c;

        hashinsert(element);

        pcode = c;

        }

        }

        //cout<<pcode<<endl;

        fwrite(&pcode, sizeof(pcode), 1, fp);

       }

       int main(void)

       {

        int t1,t2;

        //欲压缩的文本文件

        //freopen("input.txt","r",stdin);

        freopen("book5.txt","r",stdin);

        t1=time(NULL);

        hashinit();

        compress();

        t2=time(NULL);

        cout<<"Compress complete! See result.dat."<<endl;

        cout<<endl<<"Total use "<<t2-t1<<" seconds."<<endl;

       }

concurrenthashmap1.8源码如何详细解析?

       ConcurrentHashMap在JDK1.8的线程安全机制基于CAS+synchronized实现,而非早期版本的源码分段锁。

       在JDK1.7版本中,实现ConcurrentHashMap采用分段锁机制,源码小说源码源码包含一个Segment数组,实现每个Segment继承自ReentrantLock,源码并包含HashEntry数组,实现每个HashEntry相当于链表节点,源码用于存储key、实现value。源码默认支持个线程并发,实现每个Segment独立,源码互不影响。实现

       对于put流程,jingle html 源码解析与普通HashMap相似,首先定位至特定的Segment,然后使用ReentrantLock进行操作,后续过程与HashMap基本相同。

       get流程简单,通过hash值定位至segment,再遍历链表找到对应元素。需要注意的是,value是volatile的,因此get操作无需加锁。

       在JDK1.8版本中,线程安全的关键在于优化了put流程。首先计算hash值,遍历node数组。若位置为空,虚拟环绕系统源码则通过CAS+自旋方式初始化。

       若数组位置为空,尝试使用CAS自旋写入数据;若hash值为MOVED,表示需执行扩容操作;若满足上述条件均不成立,则使用synchronized块写入数据,同时判断链表或转换为红黑树进行插入。链表操作与HashMap相同,链表长度超过8时转换为红黑树。

       get查询流程与HashMap基本一致,通过key计算位置,若table对应位置的key相同则返回结果;如为红黑树结构,则按照红黑树规则获取;否则遍历链表获取数据。

String源码分析(1)--哈希篇

       本文基于JDK1.8,从Java中==符号的使用开始,解释了它判断的棋牌6603源码平台是对象的内存地址而非内容是否相等。接着,通过分析String类的equals()方法实现,说明了在比较字符串时,应使用equals()而非==,因为equals()方法可以准确判断字符串内容是否相等。

       深入探讨了String类作为“值类”的特性,即它需要覆盖Object类的equals()方法,以满足比较字符串时逻辑上相等的需求。同时,强调了在覆盖equals()方法时也必须覆盖hashCode()方法,以确保基于散列的集合(如HashMap、HashSet和Hashtable)可以正常工作。解释了哈希码(hashcode)在将不同的输入映射成唯一值中的作用,以及它与字符串内容的关系。

       在分析String类的排队叫号 小猪源码hashcode()方法时,介绍了计算哈希值的公式,包括使用这个奇素数的原因,以及其在计算性能上的优势。进一步探讨了哈希碰撞的概念及其产生的影响,提出了防止哈希碰撞的有效方法之一是扩大哈希值的取值空间,并介绍了生日攻击这一概念,解释了它如何在哈希空间不足够大时制造碰撞。

       最后,总结了哈希碰撞与散列表性能的关系,以及在满足安全与成本之间找到平衡的重要性。提出了确保哈希值的最短长度的考虑因素,并提醒读者在理解和学习JDK源码时,可以关注相关公众号以获取更多源码分析文章。

如何安全地存储密码

       ã€€ä¿æŠ¤å¯†ç æœ€å¥½çš„的方式就是使用带盐的密码hash(salted password hashing).对密码进行hash操作是一件很简单的事情,但是很多人都犯了错。接下来我希望可以详细的阐述如何恰当的对密码进行hash,以及为什么要这样做。

       ã€€ã€€é‡è¦æé†’

       ã€€ã€€å¦‚果你打算自己写一段代码来进行密码hash,那么赶紧停下吧。这样太容易犯错了。这个提醒适用于每一个人,不要自己写密码的hash算法 !关于保存密码的问题已经有了成熟的方案,那就是使用phpass或者本文提供的源码。

       ã€€ã€€ä»€ä¹ˆæ˜¯hash

       ã€€ã€€hash("hello") = 2cfdba5fb0aeeb2ac5b9ee1be5c1faeb

       hash("hbllo") = ccdfacfad6affaafe7ddf

       hash("waltz") = c0efcbc6bd9ecfbfda8ef

       ã€€ã€€Hash算法是一种单向的函数。它可以把任意数量的数据转换成固定长度的“指纹”,这个过程是不可逆的。而且只要输入发生改变,哪怕只有一个bit,输出的hash值也会有很大不同。这种特性恰好合适用来用来保存密码。因为我们希望使用一种不可逆的算法来加密保存的密码,同时又需要在用户登陆的时候验证密码是否正确。

       ã€€ã€€åœ¨ä¸€ä¸ªä½¿ç”¨hash的账号系统中,用户注册和认证的大致流程如下:

       ã€€ã€€1, 用户创建自己的账号

       2, 用户密码经过hash操作之后存储在数据库中。没有任何明文的密码存储在服务器的硬盘上。

       3, 用户登陆的时候,将用户输入的密码进行hash操作后与数据库里保存的密码hash值进行对比。

       4, 如果hash值完全一样,则认为用户输入的密码是正确的。否则就认为用户输入了无效的密码。

       5, 每次用户尝试登陆的时候就重复步骤3和步骤4。

       ã€€ã€€åœ¨æ­¥éª¤4的时候不要告诉用户是账号还是密码错了。只需要显示一个通用的提示,比如账号或密码不正确就可以了。这样可以防止攻击者枚举有效的用户名。

       ã€€ã€€è¿˜éœ€è¦æ³¨æ„çš„是用来保护密码的hash函数跟数据结构课上见过的hash函数不完全一样。比如实现hash表的hash函数设计的目的是快速,但是不够安全。只有加密hash函数(cryptographic hash functions)可以用来进行密码的hash。这样的函数有SHA, SHA, RipeMD, WHIRLPOOL等。

       ã€€ã€€ä¸€ä¸ªå¸¸è§çš„观念就是密码经过hash之后存储就安全了。这显然是不正确的。有很多方式可以快速的从hash恢复明文的密码。还记得那些md5破解网站吧,只需要提交一个hash,不到一秒钟就能知道结果。显然,单纯的对密码进行hash还是远远达不到我们的安全需求。下一部分先讨论一下破解密码hash,获取明文常见的手段。

       ã€€ã€€å¦‚何破解hash

       ã€€ã€€å­—典和暴力破解攻击(Dictionary and Brute Force Attacks)

       ã€€ã€€æœ€å¸¸è§çš„破解hash手段就是猜测密码。然后对每一个可能的密码进行hash,对比需要破解的hash和猜测的密码hash值,如果两个值一样,那么之前猜测的密码就是正确的密码明文。猜测密码攻击常用的方式就是字典攻击和暴力攻击。

       ã€€ã€€Dictionary Attack

       Trying apple : failed

       Trying blueberry : failed

       Trying justinbeiber : failed

       ...

       Trying letmein : failed

       Trying s3cr3t : success!

       ã€€ã€€å­—典攻击是将常用的密码,单词,短语和其他可能用来做密码的字符串放到一个文件中,然后对文件中的每一个词进行hash,将这些hash与需要破解的密码hash比较。这种方式的成功率取决于密码字典的大小以及字典的是否合适。

       ã€€ã€€Brute Force Attack

       Trying aaaa : failed

       Trying aaab : failed

       Trying aaac : failed

       ...

       Trying acdb : failed

       Trying acdc : success!

       ã€€ã€€æš´åŠ›æ”»å‡»å°±æ˜¯å¯¹äºŽç»™å®šçš„密码长度,尝试每一种可能的字符组合。这种方式需要花费大量的计算机时间。但是理论上只要时间足够,最后密码一定能够破解出来。只是如果密码太长,破解花费的时间就会大到无法承受。

       ã€€ã€€ç›®å‰æ²¡æœ‰æ–¹å¼å¯ä»¥é˜»æ­¢å­—典攻击和暴力攻击。只能想办法让它们变的低效。如果你的密码hash系统设计的是安全的,那么破解hash唯一的方式就是进行字典或者暴力攻击了。

       ã€€ã€€æŸ¥è¡¨ç ´è§£(Lookup Tables)

       ã€€ã€€å¯¹äºŽç‰¹å®šçš„hash类型,如果需要破解大量hash的话,查表是一种非常有效而且快速的方式。它的理念就是预先计算(pre-compute)出密码字典中每一个密码的hash。然后把hash和对应的密码保存在一个表里。一个设计良好的查询表结构,即使存储了数十亿个hash,每秒钟仍然可以查询成百上千个hash。

       ã€€ã€€å¦‚果你想感受下查表破解hash的话可以尝试一下在CraskStation上破解下下面的sha hash。

       ã€€ã€€cb4b0aafcddfee9fbb8bcf3a7f0dbaadfc

       eacbadcdc7d8fbeb7c7bd3a2cbdbfcbbbae7

       e4ba5cbdce6cd1cfa3bd8dabcb3ef9f

       b8b8acfcbcac7bfba9fefeebbdcbd

       ã€€ã€€åå‘查表破解(Reverse Lookup Tables)

       ã€€ã€€Searching for hash(apple) in users' hash list... : Matches [alice3, 0bob0, charles8]

       Searching for hash(blueberry) in users' hash list... : Matches [usr, timmy, john]

       Searching for hash(letmein) in users' hash list... : Matches [wilson, dragonslayerX, joe]

       Searching for hash(s3cr3t) in users' hash list... : Matches [bruce, knuth, john]

       Searching for hash(z@hjja) in users' hash list... : No users used this password

       ã€€ã€€è¿™ç§æ–¹å¼å¯ä»¥è®©æ”»å‡»è€…不预先计算一个查询表的情况下同时对大量hash进行字典和暴力破解攻击。

       ã€€ã€€é¦–先,攻击者会根据获取到的数据库数据制作一个用户名和对应的hash表。然后将常见的字典密码进行hash之后,跟这个表的hash进行对比,就可以知道用哪些用户使用了这个密码。这种攻击方式很有效果,因为通常情况下很多用户都会有使用相同的密码。

       ã€€ã€€å½©è™¹è¡¨ (Rainbow Tables)

       ã€€ã€€å½©è™¹è¡¨æ˜¯ä¸€ç§ä½¿ç”¨ç©ºé—´æ¢å–时间的技术。跟查表破解很相似。只是它牺牲了一些破解时间来达到更小的存储空间的目的。因为彩虹表使用的存储空间更小,所以单位空间就可以存储更多的hash。彩虹表已经能够破解8位长度的任意md5hash。彩虹表具体的原理可以参考/

       ã€€ã€€ä¸‹ä¸€ç« èŠ‚我们会讨论一种叫做“盐”(salting)的技术。通过这种技术可以让查表和彩虹表的方式无法破解hash。

       ã€€ã€€åŠ ç›(Adding Salt)

       ã€€ã€€hash("hello") = 2cfdba5fb0aeeb2ac5b9ee1be5c1faeb

       hash("hello" + "QxLUF1bgIAdeQX") = 9ecfaebfe5ed3bacffed1

       hash("hello" + "bv5PehSMfVCd") = d1d3ec2e6ffddedab8eac9eaaefab

       hash("hello" + "YYLmfY6IehjZMQ") = ac3cb9eb9cfaffdc8aedb2c4adf1bf

       ã€€ã€€æŸ¥è¡¨å’Œå½©è™¹è¡¨çš„方式之所以有效是因为每一个密码的都是通过同样的方式来进行hash的。如果两个用户使用了同样的密码,那么一定他们的密码hash也一定相同。我们可以通过让每一个hash随机化,同一个密码hash两次,得到的不同的hash来避免这种攻击。

       ã€€ã€€å…·ä½“的操作就是给密码加一个随即的前缀或者后缀,然后再进行hash。这个随即的后缀或者前缀成为“盐”。正如上面给出的例子一样,通过加盐,相同的密码每次hash都是完全不一样的字符串了。检查用户输入的密码是否正确的时候,我们也还需要这个盐,所以盐一般都是跟hash一起保存在数据库里,或者作为hash字符串的一部分。

       ã€€ã€€ç›ä¸éœ€è¦ä¿å¯†ï¼Œåªè¦ç›æ˜¯éšæœºçš„话,查表,彩虹表都会失效。因为攻击者无法事先知道盐是什么,也就没有办法预先计算出查询表和彩虹表。如果每个用户都是使用了不同的盐,那么反向查表攻击也没法成功。

       ã€€ã€€ä¸‹ä¸€èŠ‚,我们会介绍一些盐的常见的错误实现。

       ã€€ã€€é”™è¯¯çš„方式:短的盐和盐的复用

       ã€€ã€€æœ€å¸¸è§çš„错误实现就是一个盐在多个hash中使用或者使用的盐很短。

       ã€€ã€€ç›çš„复用(Salt Reuse)

       ã€€ã€€ä¸ç®¡æ˜¯å°†ç›ç¡¬ç¼–码在程序里还是随机一次生成的,在每一个密码hash里使用相同的盐会使这种防御方法失效。因为相同的密码hash两次得到的结果还是相同的。攻击者就可以使用反向查表的方式进行字典和暴力攻击。只要在对字典中每一个密码进行hash之前加上这个固定的盐就可以了。如果是流行的程序的使用了硬编码的盐,那么也可能出现针对这种程序的这个盐的查询表和彩虹表,从而实现快速破解hash。

       ã€€ã€€ç”¨æˆ·æ¯æ¬¡åˆ›å»ºæˆ–者修改密码一定要使用一个新的随机的盐

       ã€€ã€€çŸ­çš„盐

       ã€€ã€€å¦‚果盐的位数太短的话,攻击者也可以预先制作针对所有可能的盐的查询表。比如,3位ASCII字符的盐,一共有xx = ,种可能性。看起来好像很多。假如每一个盐制作一个1MB的包含常见密码的查询表,,个盐才是GB。现在买个1TB的硬盘都只要几百块而已。

       ã€€ã€€åŸºäºŽåŒæ ·çš„理由,千万不要用用户名做为盐。虽然对于每一个用户来说用户名可能是不同的,但是用户名是可预测的,并不是完全随机的。攻击者完全可以用常见的用户名作为盐来制作查询表和彩虹表破解hash。

       ã€€ã€€æ ¹æ®ä¸€äº›ç»éªŒå¾—出来的规则就是盐的大小要跟hash函数的输出一致。比如,SHA的输出是bits(bytes),盐的长度也应该是个字节的随机数据。

       ã€€ã€€é”™è¯¯çš„方式:双重hash和古怪的hash函数

       ã€€ã€€è¿™ä¸€èŠ‚讨论另外一个常见的hash密码的误解:古怪的hash算法组合。人们可能解决的将不同的hash函数组合在一起用可以让数据更安全。但实际上,这种方式带来的效果很微小。反而可能带来一些互通性的问题,甚至有时候会让hash更加的不安全。本文一开始就提到过,永远不要尝试自己写hash算法,要使用专家们设计的标准算法。有些人会觉得通过使用多个hash函数可以降低计算hash的速度,从而增加破解的难度。通过减慢hash计算速度来防御攻击有更好的方法,这个下文会详细介绍。

       ã€€ã€€ä¸‹é¢æ˜¯ä¸€äº›ç½‘上找到的古怪的hash函数组合的样例。

       ã€€ã€€md5(sha1(password))

       md5(md5(salt) + md5(password))

       sha1(sha1(password))

       sha1(str_rot(password + salt))

       md5(sha1(md5(md5(password) + sha1(password)) + md5(password)))

       ã€€ã€€ä¸è¦ä½¿ç”¨ä»–们!

       ã€€ã€€æ³¨æ„ï¼šè¿™éƒ¨åˆ†çš„内容其实是存在争议的!我收到过大量邮件说组合hash函数是有意义的。因为如果攻击者不知道我们用了哪个函数,就不可能事先计算出彩虹表,并且组合hash函数需要更多的计算时间。

       ã€€ã€€æ”»å‡»è€…如果不知道hash算法的话自然是无法破解hash的。但是考虑到Kerckhoffs’s principle,攻击者通常都是能够接触到源码的(尤其是免费软件和开源软件)。通过一些目标系统的密码–hash对应关系来逆向出算法也不是非常困难。

       ã€€ã€€å¦‚果你想使用一个标准的”古怪”的hash函数,比如HMAC,是可以的。但是如果你的目的是想减慢hash的计算速度,那么可以读一下后面讨论的慢速hash函数部分。基于上面讨论的因素,最好的做法是使用标准的经过严格测试的hash算法。

       ã€€ã€€hash碰撞(Hash Collisions)

       ã€€ã€€å› ä¸ºhash函数是将任意数量的数据映射成一个固定长度的字符串,所以一定存在不同的输入经过hash之后变成相同的字符串的情况。加密hash函数(Cryptographic hash function)在设计的时候希望使这种碰撞攻击实现起来成本难以置信的高。但时不时的就有密码学家发现快速实现hash碰撞的方法。最近的一个例子就是MD5,它的碰撞攻击已经实现了。

       ã€€ã€€ç¢°æ’žæ”»å‡»æ˜¯æ‰¾åˆ°å¦å¤–一个跟原密码不一样,但是具有相同hash的字符串。但是,即使在相对弱的hash算法,比如MD5,要实现碰撞攻击也需要大量的算力(computing power),所以在实际使用中偶然出现hash碰撞的情况几乎不太可能。一个使用加盐MD5的密码hash在实际使用中跟使用其他算法比如SHA一样安全。不过如果可以的话,使用更安全的hash函数,比如SHA, SHA, RipeMD, WHIRLPOOL等是更好的选择。

       ã€€ã€€æ­£ç¡®çš„方式:如何恰当的进行hash

       ã€€ã€€è¿™éƒ¨åˆ†ä¼šè¯¦ç»†è®¨è®ºå¦‚何恰当的进行密码hash。第一个章节是最基础的,这章节的内容是必须的。后面一个章节是阐述如何继续增强安全性,让hash破解变得异常困难。

       ã€€ã€€åŸºç¡€ï¼šä½¿ç”¨åŠ ç›hash

       ã€€ã€€æˆ‘们已经知道恶意黑客可以通过查表和彩虹表的方式快速的获得hash对应的明文密码,我们也知道了通过使用随机的盐可以解决这个问题。但是我们怎么生成盐,怎么在hash的过程中使用盐呢?

       ã€€ã€€ç›è¦ä½¿ç”¨å¯†ç å­¦ä¸Šå¯é å®‰å…¨çš„伪随机数生成器(Cryptographically Secure Pseudo-Random Number Generator (CSPRNG))来产生。CSPRNG跟普通的伪随机数生成器比如C语言中的rand(),有很大不同。正如它的名字说明的那样,CSPRNG提供一个高标准的随机数,是完全无法预测的。我们不希望我们的盐能够被预测到,所以一定要使用CSPRNG。

HashMap实现原理

        HashMap在实际开发中用到的频率非常高,面试中也是热点。所以决定写一篇文章进行分析,希望对想看源码的人起到一些帮助,看之前需要对链表比较熟悉。

        以下都是我自己的理解,欢迎讨论,写的不好轻喷。

        HashMap中的数据结构为散列表,又名哈希表。在这里我会对散列表进行一个简单的介绍,在此之前我们需要先回顾一下 数组、链表的优缺点。

        数组和链表的优缺点取决于他们各自在内存中存储的模式,也就是直接使用顺序存储或链式存储导致的。无论是数组还是链表,都有明显的缺点。而在实际业务中,我们想要的往往是寻址、删除、插入性能都很好的数据结构,散列表就是这样一种结构,它巧妙的结合了数组与链表的优点,并将其缺点弱化(并不是完全消除)

        散列表的做法是将key映射到数组的某个下标,存取的时候通过key获取到下标(index)然后通过下标直接存取。速度极快,而将key映射到下标需要使用散列函数,又名哈希函数。说到哈希函数可能有人已经想到了,如何将key映射到数组的下标。

        图中计算下标使用到了以下两个函数:

        值得注意的是,下标并不是通过hash函数直接得到的,计算下标还要对hash值做index()处理。

        Ps:在散列表中,数组的格子叫做桶,下标叫做桶号,桶可以包含一个key-value对,为了方便理解,后文不会使用这两个名词。

        以下是哈希碰撞相关的说明:

        以下是下标冲突相关的说明:

        很多人认为哈希值的碰撞和下标冲突是同一个东西,其实不是的,它们的正确关系是这样的,hashCode发生碰撞,则下标一定冲突;而下标冲突,hashCode并不一定碰撞

        上文提到,在jdk1.8以前HashMap的实现是散列表 = 数组 + 链表,但是到目前为止我们还没有看到链表起到的作用。事实上,HashMap引入链表的用意就是解决下标冲突。

        下图是引入链表后的散列表:

        如上图所示,左边的竖条,是一个大小为的数组,其中存储的是链表的头结点,我们知道,拥有链表的头结点即可访问整个链表,所以认为这个数组中的每个下标都存储着一个链表。其具体做法是,如果发现下标冲突,则后插入的节点以链表的形式追加到前一个节点的后面。

        这种使用链表解决冲突的方法叫做:拉链法(又叫链地址法)。HashMap使用的就是拉链法,拉链法是冲突发生以后的解决方案。

        Q:有了拉链法,就不用担心发生冲突吗?

        A:并不是!由于冲突的节点会不停的在链表上追加,大量的冲突会导致单个链表过长,使查询性能降低。所以一个好的散列表的实现应该从源头上减少冲突发生的可能性,冲突发生的概率和哈希函数返回值的均匀程度有直接关系,得到的哈希值越均匀,冲突发生的可能性越小。为了使哈希值更均匀,HashMap内部单独实现了hash()方法。

        以上是散列表的存储结构,但是在被运用到HashMap中时还有其他需要注意的地方,这里会详细说明。

        现在我们清楚了散列表的存储结构,细心的人应该已经发现了一个问题:Java中数组的长度是固定的,无论哈希函数是否均匀,随着插入到散列表中数据的增多,在数组长度不变的情况下,链表的长度会不断增加。这会导致链表查询性能不佳的缺点出现在散列表上,从而使散列表失去原本的意义。为了解决这个问题,HashMap引入了扩容与负载因子。

        以下是和扩容相关的一些概念和解释:

        Ps:扩容要重新计算下标,扩容要重新计算下标,扩容要重新计算下标,因为下标的计算和数组长度有关,长度改变,下标也应当重新计算。

        在1.8及其以上的jdk版本中,HashMap又引入了红黑树。

        红黑树的引入被用于替换链表,上文说到,如果冲突过多,会导致链表过长,降低查询性能,均匀的hash函数能有效的缓解冲突过多,但是并不能完全避免。所以HashMap加入了另一种解决方案,在往链表后追加节点时,如果发现链表长度达到8,就会将链表转为红黑树,以此提升查询的性能。

深入理解 HashSet 及底层源码分析

       HashSet,作为Java.util包中的核心类,其本质是基于HashMap的实现,主要特性是存储不重复的对象。通过理解HashMap,学习HashSet相对简单。本文将对HashSet的底层结构和重要方法进行剖析。

       1. HashSet简介

       HashSet是Set接口的一个实现,经常出现在面试中。它的核心是HashMap,通过构造函数可以观察到这一关系。Set接口还有另一个实现——TreeSet,但HashSet更常用。

       2. 底层结构与特性

       HashSet的特性主要体现在其不允许重复元素和无序性上。由于HashMap的key不可重复,所以HashSet的元素也是独一无二的。同时,由于HashMap的key存储方式,HashSet内部的数据没有特定的顺序。

       3. 重要方法分析

构造方法: HashSet利用HashMap的构造,确保元素的唯一性。

添加方法: 添加元素时,实际上是将元素作为HashMap的key,删除时若返回true,则表示之前存在该元素。

删除方法: 删除操作在HashMap中完成,返回值表示元素是否存在。

iterator()方法: 通过获取Map的keySet来实现迭代。

size()方法: 直接调用HashMap的size方法获取元素数量。

       总结

       HashSet的底层源码精简,主要依赖HashMap。它通过HashMap的特性确保元素的唯一性和无序性。了解了这些,对于使用和理解HashSet将大有裨益。如有疑问,欢迎留言交流。

HashSet 源码分析及线程安全问题

       HashSet,作为集合框架中的重要成员,其底层采用 HashMap 进行数据存储,简化了集合操作的复杂性。深入理解 HashMap,将有助于我们洞察 HashSet 的源码精髓。

       一、HashSet 定义详解

       1.1 构造函数

       HashSet 提供了多种构造函数,允许用户根据需求灵活创建实例。例如,使用 HashSet() 创建一个空 HashSet,或者通过 Collection 参数构造,实现与现有集合的合并。

       1.2 属性定义

       HashSet 主要属性包括容量(容量决定 HashMap 的大小)和负载因子(控制容量的扩展阈值),确保其高效存储和检索数据。

       二、操作函数

       2.1 add() - 向集合中添加元素,若元素已存在则不添加。

       2.2 size() - 返回集合中元素的数量。

       2.3 isEmpty() - 判断集合是否为空。

       2.4 contains() - 检查集合中是否包含指定元素。

       2.5 remove() - 删除集合中的指定元素。

       2.6 clear() - 清空集合,使其变为空。

       2.7 iterator() - 返回一个可迭代对象,用于遍历集合中的元素。

       2.8 spliterator() - 返回一个 Spliterator,用于更高效地遍历集合。

       三、HashSet 线程安全吗?

       3.1 线程安全解决

       HashSet 不是线程安全的,它不保证在多线程环境下的并发访问。为了确保线程安全,用户需要采用同步机制,如使用 Collections.synchronizedSet() 方法将 HashSet 转换为同步集合。同时,利用并发集合如 CopyOnWriteArrayList 和 ConcurrentHashMap 等,可以实现更高效、安全的并发操作。

相关推荐
一周热点