HashMap源码（put方法）总结思考

最新推荐文章于 2024-03-13 18:08:24 发布
最新推荐文章于 2024-03-13 18:08:24 发布
阅读量236 收藏
点赞数
文章标签： 哈希算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61334333/article/details/131920836
版权

下面是put方法的源码

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

首先我们注意到，传入键和值后，执行了putVal（）,其中还调用了hash（）,下面一个一个看

hash（）：

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

虽然看不懂在干嘛，无非就是根据关键字计算出一个hash值呗，对吧，具体操作是判一下空，为空为0，非空，则调用hashcode得出的数字再无符号右移再^，hashcoude得到的值是跟内存地址有关的，然后再做位运算，是为了让它每一位都参与运算，扰动函数，目的是让它得到的结果更为离散，减少hash冲突

putVal（）：

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;
    }

一眼顶真的是，创建了几个变量，然后第一个if开始判空，如果为空的话，resize（）,字面也能看懂，resize无非就是调整一下大小呗，看看resize（）,看看到底给n赋了什么值

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        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);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        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;
    }

仔细捋捋if结构，发现当hashmap为空时，执行下面两句

 通过查看，newCap=16;newThr=12;这是初值，然后返回putVal（）中继续看

n=15;

 让hash值与15相&,因为15的二进制时1111，所以得到的结果一定是hash的最后四位，如果tab的这个位置为空，则直接放入一个新结点，否则

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;
                }
            }

else嘛，就是发生哈希冲突了，如果值相等，比较hash,比较key，equals,都是为了判断到底Map中是否有这个建了，有的话，覆盖，如果不是上述情况，判断是不是树结点，是的话走树的流程，不是的话走拉链法的流程，其中需要注意的是：

当某个桶（hash相同）中值太多了，则会有转成红黑树的操作，其中需要判断结点树是否超过64，不超过则扩容分流，超过则转成红黑树操作

然后putVal就完事了

我们再看看resize()

写了很多，基本上也就分两种情况，一种，旧的为空，new一个长度为16，阈值为12的Node类型的数组，否则，判断长度，阈值和长度都二倍扩容

if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        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;
                        }
                    }
                }
            }
        }

含金量比较多的是这一部分，扩容肯定要将原来的数据搬过来，在搬时，由于threshold，和table的长度二倍扩容，导致求余操作的结果会不同，所以在搬运数据的过程中，采用了分流的操作

 假设原来的大小为16，与操作得到的数为10000，或00000，这样，就将原来在一起的数据分流成了两块，高位为1和高位为0的，从而在扩容后依旧满足求余操作的正确性

雨水安居
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
HashMap的put方法的源码分析(Java)
m0_67683346的博客
09-01 874
Java中HashMap的一点点源码的分析
解读HashMap中put方法的源码
qq_45593903的博客
11-23 1008
由于重写了hashCode方法，致使strKey的hashCode和 strKey2的hashCode相同，但是他们equals的结果却不相同，这里使strKey和strKey2的hashCode相同的目的是为了制造散列冲突（散列冲突指的是 ”桶“ 已经被填充的现象，也就是元素对应的node数组下标的位置已经有值了），即由于hashCode相同导致不同的元素存放在node数组的同一位置，要注意hashCode即便是相同的也会出现散列冲突，这里只是为了模拟散列冲突所以设置了相同的hashCode。
HashMap源码之put方法
weixin_42044450的博客
01-07 799
1.准备 讲put方法之前，先看两个方法，这两个方法可以根据一个key-value键值对的key确定其在entry数组中的下标位置 1.hash方法，计算key的hash值 static final int hash(Object key) { int h; // h = key.hashCode() 为第一步 取hashCode值 // h ^ (h >>> 16) 为第二步 高位参与运算， return (key == null) ? 0 : (h =
【Java集合】HashMap的put()源码详解以及JDK1.7与JDK1.8的区别
小七的博客
02-21 2053
详细讲解HashMap添加操作底层源码，以及对比put()源码在JDK1.7和JDK1.8中的区别。
HashMap中的put方法的源码解析
qq_42303467的博客
03-16 246
1.首先调用hash(key)计算hash值 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } 2.判断 传入的key是否等于null(在HashMap中是 允许存入null的) 对key值调用原生hashCode方法后进行 右移和异或运算得到 存放的数组的下标 static final int hash(Object key) { int h;
HashMap之put方法源码解读.docx
06-17
HashMap 之 put 方法源码解读 HashMap 是 Java 中一种常用的数据结构，用于存储键值对。其中，put 方法是 HashMap 中最重要的方法之一，负责将键值对存储到HashMap 中。在本文中，我们将对 HashMap 的 put 方法的...
HashMap put方法的源码分析
12-22
总结起来，理解HashMap的put方法源码对于优化Java程序中的数据处理至关重要，它揭示了HashMap如何高效地管理数据并处理冲突，这对于开发者来说是非常宝贵的编程知识。通过深入学习这些细节，我们可以更好地利用...
HashMap部分源码分析
11-18
HashMap数据结构,HashMap的构造方法,HashMap的put,HashMap的get
hashMap1.8源码
01-19
下面我们将深入探讨HashMap的源码，特别是关于`put`和`get`操作的实现细节。 HashMap的核心数据结构是一个数组配合链表/红黑树的数据结构。数组中的每个元素是一个Node对象，Node包含键、值、哈希码以及指向下一个...
HashMap集合，最详细底层源码分析及put ，get方法运行原理
12-20
HashMap的put方法工作原理如下： 1. 计算key的哈希值，通过哈希函数确定其在数组中的位置。 2. 如果该位置为空，直接创建新的Node插入。 3. 如果位置已有节点，判断现有节点是否与要插入的key相同。如果相同，则替换...
HashMap源码学习（put方法）
weixin_42414127的博客
11-26 117
1.把存入元素用hashcode产生hash值然后用hash%table.length取余产生数组下标 2.当插入元素hash相同时，存入数组某个元素的链表中， 从头部存入。然后把新插入的元素移动一下，使得get获得值变成最后put的元素 HashMap中的put方法 //阈值（java1.8中和1.7中不太一样） this.threshold = tableSizeFor(initialCapacity); //返回大于等于传入数字的二的次方数 static final int tableS
Hashmap 的源码解析以及put流程
健康平安的活着的专栏
01-30 4663
一.Hashmap的定义 Hashmap是一种常用的数据结构，底层是基于数组和链表实现的。 二.Hashmap的详情结构 2.1 数据结构 HashMap提供了三个构造函数： HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。 HashMap(int initialCapacity)：构造一个带指定初始容...
解析HashMap的put方法：详细解剖源码过程
资料免费分享，点击名片
11-06 49
哈希(hash)简单理解就是将任意长度的输入通过散列算法转换成固定长度的输出，建立一种一一对应的关系.这个输出一般称之为散列码或哈希值。所谓hash碰撞指的是经过hash算法之后, 计算出的hash码是同一个值,如下图:在hashmap中为了解决这种情况,引入了链表,也就是我们在上面看Entry内部类声明的时候有一有个next的属性.如果产生了hash冲突,就会以链表头插发的形式来记录对应的数据.举例: 假设现在角标9的位置被张三实体占用,是第一个放到角标9的位置。
HashMap中的put源码分析
LZKKJD的博客
09-08 158
HashMap put方法分析 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } hash()：hash扰动函数 static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } 如果key为...
HashMap底层源码--put方法
最新发布
泉涸的博客
03-13 334
【代码】HashMap底层源码--put方法。
HashMap中put方法（白话加源码分析）
IAMZTDSF的博客
05-06 9328
一.首先不看代码用白话分析一下流程 我们在使用put方法的时候会传进key和value参数 在我们将这两个参数传入后， 第一步，我们的put方法会去判断这个hashmap是否为null 或者长度是否为0，如果是则对hashmap数组进行resize()扩容， 第二步，put方法会根据这个key计算hash码来得到数组的位置，（这里需要解释一下，我们的hashmap默认是由一个数组加链表组成的） 得到位置后当然是继续判断这个数组下标的值是否为null，为null 自然是直接插入我们的value值，如
HashMap::put方法源码解析及执行流程图
GodHao的博客
08-29 987
HashMap::put方法 类介绍： ​ HashMap 是Java的一个集合类，继承了AbstractMap类，同时实现了Map、Cloneable、Serializable接口 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable 静态不可变的变量 //默认的初始容量 - 必须是二的幂 static final int DE
HashMap源码-Put详解（HashMap是如何添加元素的）
qq_42671519的博客
11-01 986
HashMap是Java中很重要一个部分，内容较多，因此笔者在此将其拆成一个个小块，作为自己学习知识整理的同时，也和广大网友一起讨论。 也因此，在完成系列的学习之前，将以这种小节的形式进行学习分享，并在学习结束后进行整合，排序。 一、HashMap的实际结构 首先，我们必须了解一下HashMap的实际结构： （图片来自：'是一篇很好的博客，如有时间，希望大家也能花时间在这篇博客中学习一二）https://blog.csdn.net/weixin_39621427/article/detail
HashMap中的put源码
weixin_44571544的博客
09-12 558
Map<String,String> map = new HashMap<>(); map.put("key","value"); //以put为接入点，debug查看过程 第一步调用put public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } 第二步hash方法 static final int hash(Object..
hashmap的put
09-01
- *1* [HashMap put方法的源码分析](https://download.csdn.net/download/weixin_38729607/13751823)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值