Jdk8 HashMap源码阅读

【73页PPT】美的简单高效的管理逻辑(附下载方式) 其科技领先战略依托四级研发体系(中央研究院、事业部、前沿技术、产品开发)与 “三个一代” 模式(开发一代、储备一代、研究一代),构建全球研发布局(“2+4+N” 体系,含顺德、上海双总部,美、德、意、日四大研发中心及分布式创新节点),研发投入强度持续提升。MBS(美的精益运营体系)以 “12345” 为方法论:始于客户需求,借鉴顶级企业实践,以战略部署、人才育成、日常管理为核心,追求质量、交付、成本、创新四大目标,通过精益五步法(定价值、析流、促流动、拉系统、尽善美)实现全链条优化。 阅读详情

版本 Oracle 1.8

目标

理解了以下问题,本篇笔记的目的就达到了
1. 哈希基本原理?(答:散列表、hash碰撞、链表、红黑树)
2. hashmap查询的时间复杂度, 影响因素和原理? (答:最好O(1),最差O(n), 如果是红黑O(logn))
3. resize如何实现的, 记住已经没有rehash了!!!(答:拉链entry根据高位bit散列到当前位置i和size+i位置)
4. get put 的过程。

数据结构

HashMap 基本就是哈希表,其底层实现就是围绕哈希表展开的,源码阅读也是在理解了哈希表的前提下进行为上策。
哈希表的理念就是Key值与存储位置有固定的对应关系,而这种关系需要通过某中函数来构造出来,这个函数就是哈希函数。

哈希函数有6种实现:

摘录自百度百科–哈希表
1. 直接寻址法:取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a·key + b,其中a和b为常数(这种散列函数叫做自身函数)。若其中H(key)中已经有值了,就往下一个找,直到H>(key)中没有值了,就放进去。
2. 数字分析法:分析一组数据,比如一组员工的出生年月日,这时我们发现出生年月日的前几位数字大体相同,这样的话,出现冲突的几率就会很大,但是我们发现年月日的后几位表示月份和具体日期的数字差别很>大,如果用后面的数字来构成散列地址,则冲突的几率会明显降低。因此数字分析法就是找出数字的规律,尽可能利用这些数据来构造冲突几率较低的散列地址。
3. 平方取中法:当无法确定关键字中哪几位分布较均匀时,可以先求出关键字的平方值,然后按需要取平方值的中间几位作为哈希地址。这是因为:平方后中间几位和关键字中每一位都相关,故不同关键字会以较高的概率产生不同的哈希地址。
4. 折叠法:将关键字分割成位数相同的几部分,最后一部分位数可以不同,然后取这几部分的叠加和(去除进位)作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。移位叠加是将分割后的每一部分的最低位对齐,然后相加;间界叠加是从一端向另一端沿分割界来回折叠,然后对齐相加。
5. 随机数法:选择一随机函数,取关键字的随机值作为散列地址,通常用于关键字长度不同的场合。
6. 除留余数法:取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p,p<=m。不仅可以对关键字直接取模,也可在折叠、平方取中等运算之后取模。对p的选择很重要,一般取素数或m,若p选的不好,容易产生同义词。

除留余数法最常用,也是JavaHashMap使用的方法,有关哈希冲突参考另一篇笔记 哈希冲突处理 http://www.idiary.cc/2017/07/11/Hash-%E5%86%B2%E7%AA%81%E5%A4%84%E7%90%86/。
其中链地址的处理方法正式HashMap处理冲突的基本方法。

下图是经典的hashtable结构,JDK 1.8 中链表也可以由红黑树代替。

1.8中的结构(参考:http://www.cnblogs.com/leesf456/p/5242233.html)

HashMap 类总览

首先看两段注释文档

/** 
 * This map usually acts as a binned (bucketed) hash table, but
 * when bins get too large, they are transformed into bins of
 * TreeNodes, each structured similarly to those in
 * java.util.TreeMap. Most methods try to use normal bins, but
 * relay to TreeNode methods when applicable (simply by checking
 * instanceof a node).  Bins of TreeNodes may be traversed and
 * used like any others, but additionally support faster lookup
 * when overpopulated. However, since the vast majority of bins in
 * normal use are not overpopulated, checking for existence of
 * tree bins may be delayed in the course of table methods.
 */

其中but when bins get too large, they are transformed into bins of TreeNodes这句说明了当bin过大时就会采用红黑树进行存储。

/**
 * The bin count threshold for using a tree rather than list for a
 * bin.  Bins are converted to trees when adding an element to a
 * bin with at least this many nodes. The value must be greater
 * than 2 and should be at least 8 to mesh with assumptions in
 * tree removal about conversion back to plain bins upon
 * shrinkage.
 */
static final int TREEIFY_THRESHOLD = 8;
/**
 * The bin count threshold for untreeifying a (split) bin during a
 * resize operation. Should be less than TREEIFY_THRESHOLD, and at
 * most 6 to mesh with shrinkage detection under removal.
 */
static final int UNTREEIFY_THRESHOLD = 6;
/**
 * The smallest table capacity for which bins may be treeified.
 * (Otherwise the table is resized if too many nodes in a bin.)
 * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
 * between resizing and treeification thresholds.
 */
static final int MIN_TREEIFY_CAPACITY = 64;

上面这段指明了链表在大于8的情况下会使用红黑树,在小于6的情况下重新使用链表和转化为红黑树对应的table的最小大小(64)。

HashMap 类图

类属性说明

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // 默认的初始容量是16,必须是2的幂
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;   
    // 最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30; 
    // 默认的填充因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // 当桶(bucket)上的结点数大于这个值时会转成红黑树
    static final int TREEIFY_THRESHOLD = 8; 
    // 当桶(bucket)上的结点数小于这个值时树转链表
    static final int UNTREEIFY_THRESHOLD = 6;
    // 桶中结构转化为红黑树对应的table的最小大小
    static final int MIN_TREEIFY_CAPACITY = 64;
    // 存储元素的数组,总是2的幂
    transient Node<k,v>[] table; 
    // 存放具体元素的集
    transient Set<map.entry<k,v>> entrySet;
    // 存放元素的个数,注意这个不等于数组的长度。
    transient int size;
    // 每次扩容和更改map结构的计数器
    transient int modCount;   
    // 临界值 当实际大小(容量*填充因子)超过临界值时,会进行扩容
    int threshold;
    // 填充因子
    final float loadFactor;
}

函数详解

构造函数

HashMap一共提供了四个构造函数。

/**
 * Constructs an empty <tt>HashMap</tt> with the default initial capacity
 * (16) and the default load factor (0.75).
 */
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
  * Constructs an empty <tt>HashMap</tt> with the specified initial
  * capacity and the default load factor (0.75).
  *
  * @param  initialCapacity the initial capacity.
  * @throws IllegalArgumentException if the initial capacity is negative.
  */
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
  * Constructs an empty <tt>HashMap</tt> with the specified initial
  * capacity and load factor.
  *
  * @param  initialCapacity the initial capacity
  * @param  loadFactor      the load factor
  * @throws IllegalArgumentException if the initial capacity is negative
  *         or the load factor is nonpositive
  */
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                            initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                            loadFactor);
    this.loadFactor = loadFactor;
    this.threshold = tableSizeFor(initialCapacity);
}
/**
  * Constructs a new <tt>HashMap</tt> with the same mappings as the
  * specified <tt>Map</tt>.  The <tt>HashMap</tt> is created with
  * default load factor (0.75) and an initial capacity sufficient to
  * hold the mappings in the specified <tt>Map</tt>.
  *
  * @param   m the map whose mappings are to be placed in this map
  * @throws  NullPointerException if the specified map is null
  */
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}

这里着重看下HashMap(int initialCapacity, float loadFactor)函数中的tableSizeFor(initialCapacity)。注释翻译过来的意思就是返回大于cap的最小二的幂数,这个函数的目的就是通过无符号右移动操作先取到比最小幂小1的数(后面连续几个零的二进制的数)。至于为何在开始的时候减一是因为在假设cap已经是二的幂数了,这个时候就是得到cap2倍的幂,更好的解释参见HashMap源码注解 之 静态工具方法hash()、tableSizeFor()(四)。

/**
 * Returns a power of two size for the given target capacity.
 */
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

最后一个构造函数是把一个已有的Map对象最为参数,其中主要是调用putMapEntries方法,这个函数中最后是调用了putVal,这个方法在下面介绍。

/**
 * Implements Map.putAll and Map constructor
 *
 * @param m the map
 * @param evict false when initially constructing this map, else
 * true (relayed to method afterNodeInsertion).
 */
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    int s = m.size();
    if (s > 0) {
        if (table == null) { // pre-size
            float ft = ((float)s / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                     (int)ft : MAXIMUM_CAPACITY);
            if (t > threshold)
                threshold = tableSizeFor(t);
        }
        else if (s > threshold)
            resize();
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            K key = e.getKey();
            V value = e.getValue();
            putVal(hash(key), key, value, false, evict);
        }
    }
}

PUT

有了对象,就要开始往里面放数据,现在就看下put这个方法。

/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with <tt>key</tt>, or
 *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
 *         (A <tt>null</tt> return can also indicate that the map
 *         previously associated <tt>null</tt> with <tt>key</tt>.)
 */
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

这个方法只是putVal方法的封装

/**
 * Implements Map.put and related methods
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent if true, don't change existing value
 * @param evict if false, the table is in creation mode.
 * @return previous value, or null if none
 */
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) //如果原来的table为空则resize
        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)))) //如果hash值相同、key相同(equals判断)则进行更新操作
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {              //hash冲突处理
            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)))) //链表中有hash值相同、key相同(equals判断)则进行更新操作
                    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;
}

这里取得对象在table中索引的代码就是i = (n - 1) & hash,这个实际上就是取模运算n%hash,这里为什么采用前一种方法,看一下说明

这个方法非常巧妙,它通过h & (table.length -1)来得到该对象的保存位,而HashMap底层数组的长度总是2的n次方,这是HashMap在速度上的优化。当length总是2的n次方时,h& (length-1)运算等价于对length取模,也就是h%length,但是&比%具有更高的效率。
https://zhuanlan.zhihu.com/p/21673805

上面的源码中当table为null或长度为0时需要重新初始化表格n = (tab = resize()).length;,看下resize方法:

/**
 * Initializes or doubles table size.  If null, allocates in
 * accord with initial capacity target held in field threshold. 初始化或者翻倍table大小,当原始table为空时使用threshold中存储的值初始化table。
 * Otherwise, because we are using power-of-two expansion, the
 * elements from each bin must either stay at same index, or move
 * with a power of two offset in the new table.
 * 
 * @return the table
 */
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) //当原来的table长度为0时,并且指定了初始容量(HashMap(int initialCapacity, float loadFactor)),进行到这里
        newCap = oldThr;
    else {               // 没有指定初始容量时采用默认
        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;
}

方法的文档说明中有这样一句话

Otherwise, because we are using power-of-two expansion, the elements from each bin must either stay at same index, or move with a power of two offset in the new table.

是说,因为使用的是2的幂数作为扩展的方式,这里就出现了一种情况 旧table中的元素对应(重新进行hash后)到新table中的索引位置必然在原位置或2的幂的位移(移动旧table的长度)

经过观测可以发现,我们使用的是2次幂的扩展(指长度扩为原来2倍),所以,元素的位置要么是在原位置,要么是在原位置再移动2次幂的位置。看下图可以明白这句话的意思,n为table的长度,图(a)表示扩容前的key1和key2两种key确定索引位置的示例,图(b)表示扩容后key1和key2两种key确定索引位置的示例,其中hash1是key1对应的哈希与高位运算结果。

元素在重新计算hash之后,因为n变为2倍,那么n-1的mask范围在高位多1bit(红色),因此新的index就会发生这样的变化:

因此,我们在扩充HashMap的时候,不需要像JDK1.7的实现那样重新计算hash,只需要看看原来的hash值新增的那个bit是1还是0就好了,是0的话索引没变,是1的话索引变成“原索引+oldCap”。
https://zhuanlan.zhihu.com/p/21673805

put的总体流程可参考下图

http://idiary.oss-cn-zhangjiakou.aliyuncs.com/images/2017-07-12–HashMap-%E6%BA%90%E7%A0%81%E9%98%85%E8%AF%BB/hashmap-put.jpg

参考

《手把手教你修复过期K8s集群证书:记一次K8s集群起死回生实录》 今天本想打开半年前部署的K8s测试集群跑个Demo,结果`kubectl`直接报错`certificate has expired`!作为一名云原生老司机,我决定把这次'抢救'过程记录下来,手把手带大家解决这个运维常见问题。 阅读详情

相关推荐

AVS3代码阅读HPM4.0

参考AVS3代码阅读(HPM6.0)(一.整体架构以及CU划分部分代码) 版本:HPM4.0 核心文件:app_encoder.c   要做的是帧间预测,所以前面的函数先暂时不管了,挖个坑以后再填。直接从enc_pic看起。 enc_pic()    ...

CRR的博客 3188

Java HashMap设计思想探究

最近本来想写一个HashMap相关的博客,捋一捋源码,算是对这两年开发经验的一个小考试。但是源码看着看着,博客写着写着发现HashMap的设计有一些不仔细思考可能不会理解的点。所以最终觉得写这么一篇博客,说一说我理解的HashMap的设计思想,代码基于JDK1.7和JDK1.8。 1、JDK1.7使用哈希表(HashTable)+ 链表结构的原因。 查找速度快,这是我们使用HashMap储存数据的原因,也是HashMap使用哈希表结构的原因:哈希表查找的理论复杂度是O(1),而结构相似的数组(代表类如Arr

qq896413023的博客 383

scRNA-seq | 吐血整理的单细胞入门教程(从原理到代码实操)(二)

scRNA-seq | 吐血整理的单细胞入门教程(从原理到代码实操)(二)

m0_72224305的博客 4306

HashMap中初始化大小为什么是16? 为什么链表的长度为8是变成红黑树?为什么为6时又变成链表?

hashMap术语介绍: 桶: 就是hashmap的table数组 bin: 就是挂在数组上的链表 TreeNode: 红黑树 capacity: table总容量 MIN_TREEIFY_CAPACITY :64转化为红黑树table最小大小 TREEIFY_THRESHOLD :8转化为红黑树的阈值 loadFactor:0.75table扩容因子,当实际length大于等于capacity*loadFactor时...

beikekaka的博客 1263

英飞凌TC3xx实战:PWM中点触发ADC采集+DMA自动搬运完整配置流程(基于ILLD库)

本文详细介绍了在英飞凌TC3xx系列微控制器上使用ILLD库实现PWM中点触发ADC采集并通过DMA自动搬运数据的完整配置流程。该方案适用于电机控制、电源管理等需要高精度定时采集的场景,通过GTM生成PWM信号、ADC采集和DMA传输实现全硬件自动化流程,显著提升系统效率。

weixin_42536058的博客 536

1014. 福尔摩斯的约会 (20)-PAT乙级真题

1014. 福尔摩斯的约会 (20) 大侦探福尔摩斯接到一张奇怪的字条:“我们约会吧!3485djDkxh4hhGE 2984akDfkkkkggEdsb s&hgsfdk d&Hyscvnm”。大侦探很快就明白了,字条上奇怪的乱码实际上就是约会的时间“星期四 14:04”,因为前面两字符串中第1对相同的大写英文字母(大小写有区分)是第4个字母’D’,代表星期四;第2对相同的字符是’

柳婼 の blog 2646

Java Jdk1.8 HashMap源码阅读笔记一

最近在工作用到Map等一系列的集合,于是,想仔细看一下其具体实现。一、结构public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable1、抽象类AbstractMappublic abstract class AbstractMap<K,V> implements

勿忘初心 4123

从零开始做对容量规划:一文讲透 SAP Greenfield sizing 与 Quick Sizer 落地方法

摘要 SAP项目早期硬件规划面临业务细节缺失的挑战,Greenfield sizing方法通过Quick Sizer工具将业务需求转化为硬件资源需求。该方法聚焦主要负载驱动因素而非精确预测,采用标准化问卷形式输入并发用户数、业务处理量等参数,输出内存、CPU等资源需求。关键步骤包括选择正确的Quick Sizer版本、创建sizing项目、参考SAP基准测试和认证目录校准结果,最终将需求交由硬件厂商落地。该方法特别适用于缺乏历史数据的新系统部署,帮助在不确定性中建立可控的容量规划模型,避免资源浪费或性能不足

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 218

HashMap类注释翻译(jdk1.8)

Hash table based implementation of the Map interface. This implementation provides all of the optional map operations, and permits null values and the null key. (The HashMap class is roughly equivalent to Hashtable , except that it is unsynchron...

yu749942362的专栏 760

python语言字符串练习题

描述:find()方法检测字符串中是否包含子字符串str,如果指定 beg(开始)和end(结束) 范围,则检查是否包含在指定范围内,如果包含子字符串,返回字符串中,子字符串第一个字符的索引值,否则返回-1。描述:find()方法用来检测字符串中是否包含子字符串str,在指定范围内,如果包含子字符串,返回字符串中,子字符串第一个字符的位置,否则返回-1。命令行先后输入两个字符串,然后利用find()方法找出第二个字符串在第一个字符串中出现的位置。本关需要你编写一个程序,输出字符串的长度。

国家一级致癌物 2029

【深度学习新浪潮】李飞飞团队VAGEN框架深度解析:让VLM智能体学会“三思而后行“

VAGEN框架的真正价值,不仅在于性能指标的突破,更在于重新定义了VLM智能体的发展方向——人工智能的进步不应只追求"做得对",更要实现"想得清"。李飞飞团队通过强制显式思考、动态表示适配和精细化奖励三大创新,让智能体第一次具备了可解释的世界建模能力。正如人类通过"观察-预测-行动"认识世界,VAGEN为AI注入的这种思考范式,或许正是通往通用人工智能的关键一步。对于开发者而言,开源的VAGEN框架不仅提供了强大的工具,更揭示了一个重要理念:让AI学会思考,比让它学会执行更重要。

专注:太空算力、AI infra、异构调度、大模型成本工程 282

HashMap常见问题

一. 问题背景 上一篇HashMap源码分析大概了解了HashMap的数据结构,以及实现原理。对常见的问题作一下总结。本文仅供笔者自己参考,如有不正确地方请指正,谢谢大家。 二. 常见的问题 2.1 hashmap如何解决hash冲突,为什么hashmap中的链表需要转成红黑树? hashmap采用链地址法解决冲突。链表的最坏查询情况是O(n),而红黑树是一颗二叉查找树,最坏的查询情况是O(logN)。当桶的链表变长,查询性能也跟着下降。而使用红黑树,查询性能能大大提高。对于增删操作,因为红黑树不是绝对平

Android_la的博客 3533

泛微OA提交流程到下一个节点

泛微OA后端接口强制流程归档

CXYCMY的博客 2253

【jdk8源码】HashMap集合阅读笔记

【jdk8源码】HashMap集合阅读笔记概述继承关系成员变量扩容和hash计算常用方法 概述 之前有讲到过两种List集合,ArrayList底层是使用数组实现的,LinkedList是使用双向链表实现的。HashMap更像是两者的结合,底层采用了数组+单向链表+红黑树的结构,HashMap的底层结构是一个数组(哈希桶),而数组的元素是一个单向链表,链表中的每一个节点对应了hash表中的每一个元素。当数组长度大于8的时候,就会转化为红黑树,以提升查询和插入的效率。特点是:遍历时无序、线程不安全。 继承关系

weixin_43988801的博客 2894

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

jdk8 HashMap源码阅读

一、HashMap的属性介绍 HashMap的默认初始化容量 ,在没有指定HashMap的初始化大小时, HashMap会以这个属性作为初始值 1左移四位更快的算出初始容量 16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 HashMap的最大容量:保证哈希表的数据不会超出这个容量 static final int MAXIMUM_CAPACITY = 1 << 30; 负载因子: 作

weixin_45002890的博客 172

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

【JDK1.8源码阅读】关于HashMap你应该知道的

JDK1.8源码阅读HashMap.classHashMap数据结构hashmap数据增删的处理逻辑如何增加节点如何删除节点技术细节(你应该知道的)treeifyBin链表如何转化为红黑树为什么要扩容HashMap的长度为什么要是2的n次方为什么会需要hashmaphashmap在JDK历史版本中的改动原因参考: 建议: 学习关键是效率,先上B站找hash算法和红黑树算法的视频初步了解,事半功...

大猴子 322

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

jdk8底层源码阅读 HashMap源码解析

文章目录Hash Map 解析重要计算方式重要内部变量及结构构造函数解析赋值函数解析扩容函数解析扩容函数调用关系树化与反树化函数解析树化函数树化函数之自平衡算法 Hash Map 解析 HashMap是基于哈希表的Map接口的实现类,此实现提供所有可选的映射操作,并且允许null值和null键。 HashMap类大致相当于哈希表,不同步,允许空值,不保证放入顺序,提供基本的操作稳定的性能(get和put),fail-fast迭代 HashMap中的一个实例具有影响其性能的两个参数: 初始容量和负载因子。 作

木秀林的博客 504

JDK8源码阅读(七) HashMap TODO

一、简介 本文主要讲解HashMap的原理和部分源码分析以及jdk8做的优化。 注: 本文章参考博文有: qazwyc博主的Java8 HashMap源码解析 , 尊重原创 二、分析 2.1 HashMap的结构 是一个链表散列的数据结构,即 数组和链表的结合体。这样就兼具了寻址容易和增删方便的优点。结构示意图如下: ...

请叫我猿叔叔的博客 729

HashMap源码阅读jdk1.8

HashMap源码(jdk1.8)阅读 HashMap类主要由一个Node数组Node<K,V>[] table构成 put操作时,如哈希碰撞,元素插入链表是从尾部插入(jdk7是从头部插入) put操作时,如第一次put,即table为空时,则先调用resize,然后put,非第一次,即table.length > 0时,则先put,再resize resize重新分配元素时,链表上的元素,最多会分为两部分,一部分分配在原来的低位位置,另一部分分配到新扩容的高位位置 1. put方法

leonliu06的博客 248

JDK 1.8源码阅读 HashMap

一,前言   HashMap实现了Map的接口,而Map的类型是成对出现的。每个元素由键与值两部分组成,通过键可以找对所对应的值。Map中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。   存储数据采用的哈希表结构,元素的存取顺序不能保证一致。由于要保证键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。Map接口中的集合都有两个泛型变量<K,V&g...

weixin_30488313的博客 126

JDK1.8源码阅读记录HashMap类

JDK1.8源码阅读记录 JAVA.Util包 HashMap类 1.概述 本篇文章我们来聊聊大家日常开发中常用的一个集合类 - HashMap。HashMap 最早出现在 JDK 1.2中,底层基于散列算法实现。HashMap 允许 null 键和 null 值,在计算哈键的哈希值时,null 键哈希值为 0。HashMap 并不保证键值对的顺序,这意味着在进行某些操作后,键值对的顺序可能会发生...

weixin_43459704的博客 248

HashMap源码阅读jdk1.8(dark)

说明: 终于还是开始整理源码了。为了保证客观性和可读性,大部分代码采用截图和文字注释的形式。只整理了重要方法。一些问题的解释放在最后。 HashMap(jdk1.8)1.默认参数1.1.默认大小1.2.最大容量1.3.填充因子(扩容阈值)1.4.链表转换为红黑树时的结点数目1.5.红黑树转换回链表的结点数目1.6.发生红黑树转换的最小大小1.7.基本构成:Node结点(1.7版本应为Entry结点)1.8.基本结构:table数组2.基本方法2.1.hash的实现2.2.基本构造方法2.3.get()以及g

_wdk的博客 462

JDK8源码阅读:HashMap

1.是什么 是通过K-V键值对来保存数据的数据结构,K和V都可以为null。 继承关系如下图所示: 数据结构如下图所示: 2.构造函数和主要属性 加载因子loadFactor非常重要,这个决定了什么时候进行数组的扩容操作 每次扩容时,都扩容为原来数组长度的2倍 // 存放数据的数组默认初始大小为16 static final int DEFAULT_INITIAL_CAPACITY = 1...

qq_37170583的博客 219

【JDK源码阅读】容器HashMap(jdk 1.8)

1.类图分析 1.1 容器 table 桶,元素Node节点 默认16个桶transient get、put entrySet <k,v>对 集合transient entrySet() keySet k 集合 keySet()方法 values v 集合 values()方法返回 1.3 变量...

opi 252

HashMap源码阅读分析(JDK1.8)

HashMap是JDK提供的经典容器之一,最近刚好时间充裕,于是自己看了一遍hashMap的源码实现,不同版本的JDK,HashMap的实现方式有所不同,本文主要针对JDK1.8的源码进行分析,至于各版本实现方式的不同,本文不做讨论,下面直接开始。 一、hash函数分析 map的put方法,首先调用的就是hash函数,返回key的hash值,其函数方法如下: ...

165

JDK1.8源码阅读一一HashMap

 Hashtable、HashMap、TreeMap都是常见的map实现,是以键值对的形式存储的容器类型。Hashtable是早期Java类库提供的一个同步的哈希表实现,不支持null键和值。HashMap是应用较为广泛的哈希表实现,功能上与Hashtable类似,主要区别在于HashMap不是同步的,支持null的键和值。TreeMap则是基于红黑树的一种提供顺序访问的Map,具体顺序可以由指...

weixin_37502658的博客 152
上一篇: Java.security.UnrecoverableKeyException: Cannot recover key
下一篇: maven 本地依赖存在但还是报依赖无法找到的错误
Ding-
博客等级 码龄12年 2粉丝 10原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值