基于jdk12 阅读集合源码之：HashSet和HashMap

最新推荐文章于 2022-04-09 20:10:51 发布
最新推荐文章于 2022-04-09 20:10:51 发布
阅读量87 收藏
点赞数
分类专栏： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41115379/article/details/115360902
版权

首先还是 HashSet

观看源码就会发现，其实他的大部分操作都是直接调用的HsahMap
但是他的特点就是：不会存储重复的元素，经常被用于去重，或者声明集合不为重复集合的作用
所以基于，不存储重复元素这个点，探究一下为什么
先看一下HashSet的add 方法：

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

其中map就是HashMap类
而PRESENT则是：

private static final Object PRESENT = new Object();

也就是调用了map的put方法
而map的put方法：

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

和

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

下面就是一系列的判断方法，可是这个不是HashMap的嘛，那不就意味着 HashMap也是不能有重复的？

再回过头看那个add方法：
他的实现方式就是，向Map 中新增元素，将对象作为Key,将一个静态方法作为Value,利用Map中的key如果重复的话，就会自动覆盖，也就是利用了Mapkey集合是唯一的这个特点。

所以还是得重点看看HashMap

网上说法是，HashMap由数组和链表组成
在这里插入图片描述
大致就是长这样的。然后结合HashMap的添加和查询

  • 添加元素的时候，先查看会不会造成Hash冲突，如果造成了，就把值放在对应的链表中，而如果没有造成的话，就创建一个新的数组元素放置在数组中
  • 当查询元素的时候，先查询key的Hash，如果存在的话，就遍历链表进行查找

但是在JDK1.8之后，就变成了 数组加链表加红黑树
在这里插入图片描述
（当Hash 发生冲突时，就采用链表或者红黑树来解决，当同一个hash值结点树小于8就采用链表，否则就采用红黑树）这也是为了提高查询速度

这里就对HashMap的添加方法进行详细讲解：
http://www.2cto.com/kf/201505/401433.html 这里是对HashMap 的源码剖析
总的逻辑就是：

  1. 判断键值对数组tab[]是否为空或为null，否则resize()；
  2. 根据键值key计算hash值得到插入的数组索引i，如果tab[i]==null，直接新建节点添加，否则转入3
  3. 判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理。

代码解释如下:

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
    //如果这个数组 是空的，活着长度为空的话 那就进行resize(重新分配内存操作）
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //如果添加的结点位置是null，说明没有相同的hash值的数据进来，就可以直接设置到数组的指定位置
    //通过 (n-1)&hash来找到put 的位置
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        //如果已经存在数据了的话 就进行判断 这个位置的hash值相同，并且key值和插入的key值相同 这里是用== 和equals进行判定
        //是否完全相等 是的话 就直接覆盖
        HashMap.Node<K,V> e; K k;
        if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果不是的话 就说明出现了Hash冲突 需要直接将元素添加到红黑树或者链表当中了
        //这个属于 红黑树处理冲突 创建一个 TreeNode
        else if (p instanceof HashMap.TreeNode)
            // 先进行一个判断节点是否为红黑树 如果是的话 就直接添加到红黑树当中去
            e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //这里是通过链表处理冲突
            for (int binCount = 0; ; ++binCount) {
                //对链表进行遍历判断是否存在Null
                if ((e = p.next) == null) {
                    //如果结点是null的话 就构造结点 加入到链表的尾部就行了
                    p.next = newNode(hash, key, value, null);
                    //如果链表的长度 大于或者等于 8-1=7  那就需要转化为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //如果发现是同一个元素的话 就直接跳出循环
                //这里 为什么会发现是同一个元素呢
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                //更新p到下一个节点
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            //如果原来的元素为null 且允许修改value的话 就进行修改
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //如果添加后的值 小于最大保存数 那就再次调整大小
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

然后是get 操作

final HashMap.Node<K,V> getNode(int hash, Object key) {
    HashMap.Node<K,V>[] tab; HashMap.Node<K,V> first, e; int n; K k;
    //判断数组是否为空 空的话 就直接最后返回null 就行了
    if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
        //如果检查的第一个元素就是对应的值的话 就直接返回
        if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        //再开始遍历
        if ((e = first.next) != null) {
            if (first instanceof HashMap.TreeNode)
                //如果是红黑树的话 就进行红黑树的查询方式
                return ((HashMap.TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                //不然就是按照链表的，一直查询下去
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

然后是resize 也就是调整数组大小
这里有个知识点 HashMap的懒加载：

构造完HashMap 对象后，只要不进行put方法插入元素之前，HashMap并不会去初始化或者扩容table

final HashMap.Node<K,V>[] resize() {
    //没插入之前的Hash数组 oldTab
    HashMap.Node<K,V>[] oldTab = table;
    //数组的长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //数组的临界值
    int oldThr = threshold;
    //初始化新数组的长度和临界值
    int newCap, newThr = 0;
    if (oldCap > 0) {
        //oldCap >0 说明不是首次初始化 因为HashMap是懒加载的
        //oldCap如果大于最大值的话
        if (oldCap >= MAXIMUM_CAPACITY) {
            //就把临界值换成整数的最大值
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //其他情况 就需要把容量扩大两倍，但扩容之后依然需要小于最大值，old长度也需要大于16
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                oldCap >= DEFAULT_INITIAL_CAPACITY)
            //临界值也需要扩容
            newThr = oldThr << 1; // double threshold
    }
    // oldCap<0 的前提下 oldThr>0 说明已经初始化了，可能是做了把元素删除这类的操作 临界值还存在
    //因为首次初始化的话 oldThr是等于0 的
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {// zero initial threshold signifies using defaults
        //这里是首次初始化 所以都采取默认值就行了
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //呼应之前的  newThr = oldThr << 1 也就是初始化容量小于16
    //这里对新的临界值在进行修改注入
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                (int)ft : Integer.MAX_VALUE);
    }
    //这里才是真正的开始 把之前分析好的newThr 真正的赋值回去
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
            //初始化
    HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
    //赋值回去 当前的table
    table = newTab;
    //这里就需要把之前的元素 赋值到新的当中
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            //临时变量
            HashMap.Node<K,V> e;
            //当前的哈希桶的位置不是null，也就是数组下标处有值，就可能发生冲突
            if ((e = oldTab[j]) != null) {
                //把已经赋值之后的变量置为null 方便回收
                oldTab[j] = null;
                //下标处的结点没有下一个元素
                if (e.next == null)
                    //赋值到 这个新的位置 需要记住一下 (e.hash & (newCap - 1)是用来计算位置）
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof HashMap.TreeNode)
                    //如果是红黑树的话 就存在Hash冲突
                    ((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    //这里是链表结构 也需要把表进行转移到newTable
                    HashMap.Node<K,V> loHead = null, loTail = null;
                    HashMap.Node<K,V> hiHead = null, hiTail = null;
                    HashMap.Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

然后是remove移除元素：

//参数就是 Hash值 key value 第四个true的话 就是表示删除key对应的value，不删除key  第五个false的话 就表示删除不移动结点
final HashMap.Node<K,V> removeNode(int hash, Object key, Object value,
                                   boolean matchValue, boolean movable) {
    //tab 哈希数组 P是数组下标结点 n 是长度 index是当前数组下标
    HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, index;
    //数组不为0 长度大于0 并且其Hash存在相关元素
    if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
        //node就是要被删除的结点 然后是当前结点和当前结点的value
        HashMap.Node<K,V> node = null, e; K k; V v;
        //如果数组的下标刚好是要删除的结点 就把值复制给临时变量
        if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        //不然就下一个
        else if ((e = p.next) != null) {
            if (p instanceof HashMap.TreeNode)
                //如果是红黑树的话 就遍历红黑树
                node = ((HashMap.TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                //这里就按照链表的方式遍历
                do {
                    if (e.hash == hash &&
                            ((k = e.key) == key ||
                                    (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        //找到要删除的结点之后 进行matchValue的判断 并进行删除
        if (node != null && (!matchValue || (v = node.value) == value ||
                (value != null && value.equals(v)))) {
            if (node instanceof HashMap.TreeNode)
                ((HashMap.TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                //这里就是链表的删除方法了
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

还有个细节：

HashMap中根据hash值定位的方式是 (n-1) & hash 的方式，最大值也就是 (n-1) 因此不会出现数组越界的问题

https://juejin.cn/post/6844903744711163911 参考这个

关切得大神
关注
专栏目录
源码解析jdk7.0集合：HashSet的底层实现原理.pdf
03-11
HashSet作为Java集合框架中一个重要的非同步集合实现，它在JDK 7.0中的底层实现原理是基于HashMap来存储和操作数据的。下面就详细介绍HashSet的实现原理。 首先，HashSet是Set接口的一个实现类，它用于存储唯一性的...
java类源码-JavaCollection:基于JDK1.8的集合类源码分析
05-19
`HashSet`和`HashMap`是基于哈希表实现的集合，它们提供快速的查找和插入操作。`HashSet`不包含重复元素，而`HashMap`则是一个键值对的集合。在JDK 1.8中，`HashMap`引入了红黑树数据结构，当哈希冲突达到一定比例时...
HashMap源码分析(jdk12)
yahahassr的博客
03-10 197
1. 初始化，hashMap初始化容量默认大小为16，默认负载因子为0.75F 一共有3个构造器 无参 带初始化容量 带初始化容量和初始化加载因子 前两个构造器都是调用第三个构造器。如果没有设置初始化容量或负载因子，以默认值创建。值得一提的是： 在调用构造器创建HashMap时不会立即创建容器，（在jdk1.8之后为 Node<K,V>[] table 用于存储键值对...
HashMap源码分析（基于jdk12）
Mike的博客
08-24 154
HashMap作为一个常用的容器类，继承于AbstractMap，并实现了Map等一系列接口 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { 从源码对于HashMap的介绍来看，与HashTable类似，不...
HashMap实现原理分析
JHON07的博客
07-17 263
转:https://blog.csdn.net/xuehuagongzi000/article/details/71449179 1. HashMap的数据结构   数据结构中有数组和链表来实现对数据的存储，但这两者基本上是两个极端。       数组 数组存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1)；数组的特点是：寻址容易，插入和删除困难；...
JDK12中HashMap源码解读
王飞的博客
04-05 210
占坑，待完成
JDK源码阅读(6)：HashSet类阅读笔记
pedro7k的博客
11-09 85
HashSet public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable { ... } 1. map属性和构造方法 HashSet中最重要的属性是一个HashMap，在构造方法中会创建它。 private transient HashMap<E,Object> map; public HashS
jdk：HashSet基于HashMap实现
BlackCutter的博客
06-23 580
以前就听过，HashSet基于HashMap实现，HashMap的键部分就是一个HashSet，但是今天看了一眼源码之后，我就觉得这些说法并不够清晰，至少没有我看了一眼源码来的痛快。HashSet源码中的两行代码：private transient HashMap<E,Object> map; public HashSet() { map = new HashMap<E,Object>();
Java集合源码实现五：HashSet（jdk1.8）
零一的博客
01-10 625
Java集合源码实现五：HashSet（jdk1.8） Java集合源码实现五HashSetjdk18 类继承关系 什么是HashSet HashSet数据结构 源码分析 类继承实现 成员变量 主要方法 构造方法 添加元素 删除元素类继承关系：(*=>：接口实现)java.lang.Object   –java.util.AbstractCollection =>Collection     –
我的jdk源码（十五）：HashSet类
Java觉浅的博客
05-28 399
一、概述 HashSet类是常用的Set集合类，底层是采用HashMap来实现的，我们通常利用HashSet类的元素不重复的特性来达到去重的效果，那么跟随源码去一探究竟吧。 二、源码分析 (1) 类的声明 public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable 在类的声明中我们可以看...
Java集合:HashSet,HashMap.......
m0_51586386的博客
04-09 1049
集合 一、集合的理解 首先理解数组： 长度开始时必须指定； 保存的必须为同一类型的元素； 使用数组进行增删元素比较麻烦； 集合： 可以动态的保存任意多个对象； 提供了一系列方便操作对象的方法：add , remove , set , get 等； 使用集合进行增删元素简单； 二、集合的框架体系 集合主要分为两大类： 集合主要分为两组；（单列集合和双列集合）； Collection 接口有两个重要的子接口 List 和 Set ，他们实现子类都是单列集合； Map 接口实现的子类时双列集合
JDK源码分析系列之四：HashSet深入理解以及源码分析
06-07 347
引言
Java集合框架深度解析：List、HashMap、HashSet等源码分析
本文档是对Java基础集合框架的深入分析和总结，涵盖了List、HashMap、HashSet等主要集合类的底层源码和操作方法。通过阅读这篇总结，读者可以了解到Collection接口及其子接口List、Map、Set的相关方法，以及...
Word中数据的计算.pdf
10-11
Word中数据的计算.pdf
Microsoft Project Portfolio Server 2007 Datasheet_CN_Final.doc
10-11
Microsoft Project Portfolio Server 2007 Datasheet_CN_Final.doc
JaroWinklerSimilarity
10-11
Jaro-Winkler 相似度（Jaro-Winkler Similarity）是一种用于衡量两个字符串相似度的算法，特别适用于比较短字符串或需要考虑字符顺序的情况。它在信息检索、数据清洗和拼写校正等领域广泛应用。 主要特点 基本原理： Jaro-Winkler 相似度基于 Jaro 距离，这一距离主要考虑字符的匹配和顺序。 该算法首先计算两个字符串的匹配字符和匹配位置，以此计算相似度。 加权机制： Jaro-Winkler 在 Jaro 的基础上增加了对前缀匹配的奖励，这意味着如果两个字符串的开头部分相同，算法将给予更高的相似度评分。 结果范围： 相似度的值在 0 到 1 之间，1 表示完全相同，0 表示完全不同。
神经网络模型来检测肺炎的CT的影像
最新发布
10-11
神经网络模型来检测肺炎的CT的影像
20241011-0909
10-11
ffff
BitTorrent协议基础
10-11
DHT,TRACKER
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值