HashMap1.7源码讲解

HashMap源码详解 前言 HashMap 是基于哈希表对 Map 接口的实现,增删改查的时间复杂度都可以看成是O(1)(平均地),性能很高,但是内存的消耗也很高。存储的是键值对,允许存储 key 为 null 和 value 为 null,但是一个 HashMap 中只有一个 key 为 null,可以有多个 value 为 null。 哈希表有哈希函数,而且可能存在哈希碰撞/哈希冲突的问题。 哈希函数:一种算法,可以让 key 映射到哈希表中的存储位置。 哈希冲突:哈希表会让 key 通过一个哈希函数映射到哈希表中的某个位置 阅读详情

先进行基本操作:

public static void main(String[] args) {
    Map<String,Object> map=new HashMap<>();
    map.put("key=1","value=100");
    Object put=map.put("key=1","value=200");
    System.out.println(put);
    System.out.println(map.get("key=1"));
}

输出:

value=100
value=200

  • value=100说明这put()是有返回值的,返回被覆盖的那个旧值,
  • value=200说明key相同会覆盖,一个key对应一个value
    Hash Map就是哈希表的操作,HashMap就是解决冲突的链地址法,索引值一样的话,就形链表,jdk1.7用的的是头插法,1.8用的是尾插法,1.7认为头插比较快,因为尾插需要遍历到最后一个链表地址,再插入。
  • 1.7会导致并发时死循环,就是在扩容时,由于是反着的,AB两人同时操作扩容,A扩容完了,B是不知道的,在A扩容好的里面,e和e.next反过来了,会导致循环链表,并一直循环。

开始看源码:

1、存储结构

static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;//存储指向下一个Entry的引用,单链表结构
        int hash;//对key的hashcode值进行hash运算后得到的值,存储在Entry,避免重复计算

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }

在这里插入图片描述

2、构造方法

    //默认初始化化容量,即16  
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

//最大容量,即2的30次方  
static final int MAXIMUM_CAPACITY = 1 << 30;  

//默认装载因子  
static final float DEFAULT_LOAD_FACTOR = 0.75f;  

//HashMap内部的存储结构是一个数组,此处数组为空,即没有初始化之前的状态  
static final Entry<?,?>[] EMPTY_TABLE = {};  

//空的存储实体  
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;  

//实际存储的key-value键值对的个数
transient int size;

//阈值,当table == {}时,该值为初始容量(初始容量默认为16);当table被填充了,也就是为table分配内存空间后,threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold
int threshold;

//负载因子,代表了table的填充度有多少,默认是0.75
final float loadFactor;

//用于快速失败,由于HashMap非线程安全,在对HashMap进行迭代时,如果期间其他线程的参与导致HashMap的结构发生变化了(比如put,remove等操作),需要抛出异常ConcurrentModificationException
transient int modCount;

//默认的threshold值  
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
	/*
	*initialCapacity传进来的数组容量,loadFactor扩容因子0-1
	*先对这两个值进行合法判断
	*threshold = initialCapacity;把容量赋值给了一个阈值?
	*/
    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;//赋值扩容因子
        threshold = initialCapacity;
        init();
    }
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        inflateTable(threshold);

        putAllForCreate(m);
    }

threshold = (int)(capacity * loadFactor);1.6
threshold = initialCapacity;1.7
this.threshold = tableSizeFor(initialCapacity);1.8

3.put()添加

/*
*	首先判断table数组是否为空,如果是空的进行初始化	inflateTable()
*/
public V put(K key, V value) {
        //如果table数组为空数组{},进行数组填充(为table分配实际内存空间),入参为threshold,此时threshold为initialCapacity 默认是1<<4(=16)
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);//分配数组空间,最小是二
        }
       //如果key为null,存储位置为table[0]或table[0]的冲突链上
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);//对key的hashcode进一步计算,确保散列均匀
        int i = indexFor(hash, table.length);//获取在table中的实际位置
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        //如果该对应数据已存在,执行覆盖操作。用新value替换旧value,并返回旧value
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;//下面返回老值
                e.value = value;//直接覆盖
                e.recordAccess(this);//调用value的回调函数,其实这个函数也为空实现
                return oldValue;
            }
        }
        modCount++;//保证并发访问时,若HashMap内部结构发生变化,快速响应失败
        addEntry(hash, key, value, i);//新增一个entry
        return null;
    }

inflateTable的源码如下:

private void inflateTable(int toSize) {
        int capacity = roundUpToPowerOf2(toSize);//capacity一定是2的次幂
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        //此处为threshold赋值,取capacity*loadFactor和MAXIMUM_CAPACITY+1的最小值,capaticy一定不会超过MAXIMUM_CAPACITY,除非loadFactor大于1
        table = new Entry[capacity];//分配空间
        initHashSeedAsNeeded(capacity);//选择合适的Hash因子
    }

inflateTable 初始化表这个方法用于为主干数组table在内存中分配存储空间,调用的Integer.highestOneBit,通过roundUpToPowerOf2(toSize)可以确保capacity为大于或等于toSize的最接近toSize的二次幂,比如toSize=13,则capacity=16;to_size=16,capacity=16;to_size=17,capacity=32。其实现如下:

private static int roundUpToPowerOf2(int number) {
        // assert number >= 0 : "number must be non-negative";
        return number >= MAXIMUM_CAPACITY
                ? MAXIMUM_CAPACITY
                : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
    }

Integer.highestOneBit很巧妙
位运算代替小于等于10的最小2次方数

	/*
	*	假设我想找到	小于等于10的最小2次方数
	*	10------》1010
	*	8-------》1000
	*	
	*	现在看这个方法,假设我传进来了一个10( ... 0000 1010)
	*	右移一位							( ... 0000 0101)  进行或运算,有一则为一
	*	结果							( ... 0000 1111)	
	*	右移两位							( ... 0000 0011)  进行或运算
	*	结果							( ... 0000 1111)	
	*	。。。
	*	最终i=		 (  ... 0000 1111)	
	*  	i进行右移一位 ( 	... 0000 0111)进行相减
	* 	最终的返回值为(... 0000 1000) 8
	*/
  public static int highestOneBit(int i) {
        // HD, Figure 3-1
        i |= (i >>  1);
        i |= (i >>  2);
        i |= (i >>  4);
        i |= (i >>  8);
        i |= (i >> 16);
        return i - (i >>> 1);
    }

hash():对key的hashcode进一步进行计算

//用了很多的异或,移位等运算,对key的hashcode进一步进行计算以及二进制位的调整等来保证最终获取的存储位置尽量分布均匀
final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {//这里针对String优化了Hash函数,是否使用新的Hash函数和Hash因子有关  
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode();

        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

从上面的操作看以看出,影响HashMap元素的存储位置的只有key的值,与value值无关。
通过hash函数得到散列值后,再通过indexFor进一步处理来获取实际的存储位置,其实现如下:
indexFor()其实就是hash值太长,截短点

    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);
    }

1,HashMap的初始容量和扩容都是以2的次方来进行的,为啥呢?

  • 因为length-1换算成二进制的话,后几位都是1,0000 1111,这样与添加元素的hash值既可以进行位运算,速度快,又能够充分的散列,使得添加的元素均匀分布在HashMap的每个位置上,减少hash碰撞。就比如数组长度为8,2的3次方为8(1000),length-1的二进制表示就是0111, 而按位与计算的原则是两位同时为“1”,结果才为“1”,否则为“0”。假设计算出来的hash值为135,所以h& (length-1)运算从数值上来讲其实等价于对length取模,也就是h%length。

2.如果不满足前提条件“HashMap的初始容量和扩容都是以2的次方来进行的”,会发生什么问题呢?

  • 假设当前table的length是15,二进制表示为1111,那么length-1就是1110,此时有两个hash值为8和9的key需要计算索引值:
    这样一来就产生了相同的索引值,也就是说两个hash值为8和9的key会定位到数组中的同一个位置上形成链表,这就产生了碰撞
    同时,我们也可以发现,当数组长度为15的时候,hash值会与length-1(1110)进行按位与,那么计算结果最后一位永远是0,而0001,0011,0101,1001,1011,0111,1101这几个位置永远都不能存放元素了,会造成严重的空间浪费,更糟的是这种情况下,数组可以使用的位置比数组长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率。
    因此可以看出,只有当数组长度为2的n次方时,不同的key计算得出的index索引相同的几率才会较小,数据在数组上分布也比较均匀,碰撞的几率也小,相对的,查询的时候就不用遍历某个位置上的链表,这样查询效率也就较高了。
    此外,位运算快于十进制运算,hashmap扩容也是按位扩容,这样同时也提高了运算效率。
    最后,得到存储的下标位置后,我们就可以将元素放入HashMap中,具体通过addEntry实现:
void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);//当size超过临界阈值threshold,并且即将发生哈希冲突时进行扩容,新容量为旧容量的2倍,放的table[index]刚好没有值,就放进去,不扩容了
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);//扩容后重新计算插入的位置下标
        }

        //把元素放入HashMap的桶的对应位置
        createEntry(hash, key, value, bucketIndex);
    }
//创建元素  
    void createEntry(int hash, K key, V value, int bucketIndex) {  
        Entry<K,V> e = table[bucketIndex];  //获取待插入位置元素
        table[bucketIndex] = new Entry<>(hash, key, value, e);//这里执行链接操作,使得新插入的元素指向原有元素。
//这保证了新插入的元素总是在链表的头  
        size++;//元素个数+1  
    }  

重点:
Entry<K,V> e = table[bucketIndex];
//获取待插入位置元素,就是拿到3–>2–>1这个链表,给e
table[bucketIndex] = new Entry<>(hash, key, value, e);
//这里执行链接操作,使得新插入的元素指向原有元素。就是Entry那个构造,把新加的 key, value, 和刚拿到的e连接起来了,在放到table的位置。

4、扩容操作

就是resize();
主要是
1.transfer()老表数据拷贝到新表
2.更新table
3.更新阈值(记得和最大值减一比较)

 //按新的容量扩容Hash表  
    void resize(int newCapacity) {  
        Entry[] oldTable = table;//老的数据  
        int oldCapacity = oldTable.length;//获取老的容量值  
        if (oldCapacity == MAXIMUM_CAPACITY) {//老的容量值已经到了最大容量值  
            threshold = Integer.MAX_VALUE;//修改扩容阀值  
            return;  
        }  
        //新的结构  
        Entry[] newTable = new Entry[newCapacity];  
        transfer(newTable, initHashSeedAsNeeded(newCapacity));//1.将老的表中的数据拷贝到新的结构中  
        table = newTable;//2.修改HashMap的底层数组  
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);//3.修改阀值  
    }  

如果数组进行扩容,数组长度发生变化,而存储位置 index = h&(length-1),index也可能会发生变化,需要重新计算index,(1.8不管这个,直接按原来的位置加容量)我们先来看看transfer这个方法:

//将老的表中的数据拷贝到新的结构中  
    void transfer(Entry[] newTable, boolean rehash) {  
        int newCapacity = newTable.length;//容量  
        for (Entry<K,V> e : table) { //遍历所有桶
            while(null != e) {  //遍历桶中所有元素(是一个链表)
                Entry<K,V> next = e.next;  
                if (rehash) {//如果是重新Hash,则需要重新计算hash值  
                    e.hash = null == e.key ? 0 : hash(e.key);  
                }  
                int i = indexFor(e.hash, newCapacity);//定位Hash桶  
                e.next = newTable[i];//元素连接到桶中,这里相当于单链表的插入,总是插入在最前面
                newTable[i] = e;//newTable[i]的值总是最新插入的值
                e = next;//继续下一个元素  
            }  
        }  
    }  

5、get操作

    //获取key值为key的元素值  
    public V get(Object key) {  
        if (key == null)//如果Key值为空,则获取对应的值,这里也可以看到,HashMap允许null的key,其内部针对null的key有特殊的逻辑  
            return getForNullKey();  
        Entry<K,V> entry = getEntry(key);//获取实体  

        return null == entry ? null : entry.getValue();//判断是否为空,不为空,则获取对应的值  
    }  

    //获取key为null的实体  
    private V getForNullKey() {  
        if (size == 0) {//如果元素个数为0,则直接返回null  
            return null;  
        }  
        //key为null的元素存储在table的第0个位置  
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {  
            if (e.key == null)//判断是否为null  
                return e.value;//返回其值  
        }  
        return null;  
    }  

get方法通过key值返回对应value,如果key为null,直接去table[0]处检索,遍历链表。我们再看一下getEntry这个方法:

//获取键值为key的元素  
    final Entry<K,V> getEntry(Object key) {  
        if (size == 0) {//元素个数为0  
            return null;//直接返回null  
        }  

        int hash = (key == null) ? 0 : hash(key);//获取key的Hash值  
        for (Entry<K,V> e = table[indexFor(hash, table.length)];//根据key和表的长度,定位到Hash桶  
             e != null;  
             e = e.next) {//进行遍历  
            Object k;  
            if (e.hash == hash &&  
                ((k = e.key) == key || (key != null && key.equals(k))))//判断Hash值和对应的key,合适则返回值  
                return e;  
        }  
        return null;  
    }  

HashMap的使用总结

  • HashMap是基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作,并允许使用 null 值和 null 键。(除了非同步和允许使用 null 之外,HashMap 类与 Hashtable 大致相同。)此类不保证映射的顺序,特别是它不保证该顺序恒久不变(发生扩容时,元素位置会重新分配),并且无序,就是放的时候是随即着地放的。
  • 迭代 collection 视图所需的时间与 HashMap 实例的“容量”(桶的数量)及其大小(键-值映射关系数)成比例。所以,如果迭代性能很重要,则不要将初始容量设置得太高(或将加载因子设置得太低)。
  • HashMap 的实例有两个参数影响其性能:初始容量 和加载因子。容量 是哈希表中桶的数量,初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时,则要对该哈希表进行 rehash 操作(即重建内部数据结构),从而哈希表将具有大约两倍的桶数。通常,默认加载因子 (.75) 在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销,但同时也增加了查询成本(在大多数 HashMap 类的操作中,包括 get 和 put 操作,都反映了这一点)。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子,以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子,则不会发生 rehash 操作。
  • 如果很多映射关系要存储在 HashMap 实例中,则相对于按需执行自动的 rehash 操作以增大表的容量来说,使用足够大的初始容量创建它将使得映射关系能更有效地存储。
  • HashMap的实现不是同步的。如果在多线程操作下,应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作,以防止对映射进行意外的非同步访问,如下所示:
    Map m = Collections.synchronizedMap(new HashMap(…));
  • 由所有此类的“collection 视图方法”所返回的迭代器都是快速失败 的(modcount):在迭代器创建之后,如果从结构上对映射进行修改,除非通过迭代器(itriter)本身的 remove 方法,其他任何时间任何方式的修改,迭代器都将抛出 ConcurrentModificationException。
【GEE实战】Sen+MK趋势分析:从代码到地图,解锁植被变化时空密码 本文详细介绍了在Google Earth Engine(GEE)平台上使用Sen斜率估计和Mann-Kendall(MK)检验进行植被变化趋势分析的全流程。从遥感数据加载、Sen斜率计算到MK显著性检验,结合代码示例和实战经验,帮助读者掌握植被时空变化分析的实用技巧,为生态监测和环境保护提供数据支持。 阅读详情

相关推荐

win10下面安装MTK USB VCOM 驱动

win10下面安装MTK USB VCOM 驱动1.概述2.驱动准备3.主要步骤3.1禁用win10对没有签名驱动限制3.2通过设备管理器安装mtk usb vcom驱动3.3工具版本问题4.禁用win10对没有签名的驱动限制4.1在设置中打开 更新和安全4.2进入恢复4.3在高级启动中点击立即重新启动4.4电脑重启后的几个动作5.通过设备管理器安装MTK USB VCOM 驱动5.1准备驱动5....

qimi123456的专栏 3万+

HashMap- 1.7源码解析

HashMap- 1.7源码解析 存储结构 内部包含了一个 Entry 类型的数组 table。Entry 存储着键值对。它包含了四个字段,从 next 字段我们可以看出 Entry 是一个链表。即数组中的每个位置被当成一个桶,一个桶存放一个链表。HashMap 使用拉链法来解决冲突,同一个链表中存放哈希值和散列桶容量取模运算结果相同的 Entry。 啊啊 transient Entry[] table; //位桶数组 /** * Entry类实现了Map.Entry接口 * 即 实现了get

qq_50596778的博客 681

【前端HTML生成条形码——MQ】

本文将展示前端HTML如何根据用户输入内容生成对应的条形码,附HTML和JS代码。代码如下(示例):

weixin_42588676的博客 1957

小青龙的Java面试笔记

计算机网络 一、谈下你对五层网络协议体系结构的理解? 1)应用层 应用层(application-layer)的任务是通过应用进程间的交互来完成特定网络应用。应用层协议定义的是应用进程(进程:主机中正在运行的程序)间的通信和交互的规则。对于不同的网络应用需要不同的应用层协议。在互联网中应用层协议很多,如域名系统 DNS,支持万维网应用的 HTTP 协议,支持电子邮件的 SMTP 协议等等。我们把应用层交互的数据单元称为报文。 2)运输层 运输层(transport layer)的主要任务就是负责向两台主机

weixin_44112759的博客 779

ubuntu18.04在carla中导入Roadrunner自建的地图

进入Carla根目录下的Import文件夹在Import文件夹下面新建一个文件夹 这里我取名为RoadA进入新建的文件夹,创建json文件,json文件的名字与文件夹名字相同再将从RoadRunner中导出的地图文件夹(map)放入新建的文件夹目录下重点关注.fbx和.xodr文件然后打开新建的json文件添加并修改如下代码name为RoadRunner中导出的地图文件夹名字。

justinyjf的博客 1899

探索Vortex开源GPGPU:RISC-V SIMT架构(2),指令Decode

本文分析了Vortex RISC-V内核的Decode模块设计。文章详细介绍了指令译码过程,包括操作码、功能码和寄存器字段的提取,以及不同类型指令(R/I/S/B/U/UJ)的立即数处理。重点阐述了基于操作码和功能码的分层译码逻辑,包括ALU运算、分支跳转、系统调用等指令的译码规则。此外,还描述了定制指令的处理机制以及与调度器的握手协议。Decode模块通过组合逻辑实现快速译码,并将结果传递给下级Issue模块,同时协调指令流控制。

weixin_55313207的博客 1794

java集合——HashMap源码

1、jdk1.7关键代码 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { // 默认数组大小 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 // 默认加载因子 static final

qq_35784669的博客 1133

SAP-PM设备模块-PM主数据之维护策略

预防性维护的一种计划方式,需要先建立维护策略什么情况下需要创建维护策略?

TRUIXIANG的博客 2572

hash函数 java_几种常见的hash函数

概览最近在看redis源码,发现redis采用了几种不同的算法来计算Hash Code;因此打算借此整理下JDK中的实现,加深理解;RedisThomas Wang's 32 bit Mix Function关于该算法的具体内容,可以参考这篇文章,算法源码如下:public int hash32shift(int key){key = ~key + (key << 15); // ke...

weixin_42356292的博客 2173

Win10下YOLOv8环境搭建避坑指南:从CUDA 11.6到cuDNN配置全流程

本文详细介绍了在Windows 10系统下搭建YOLOv8环境的完整流程,包括CUDA 11.6和cuDNN的配置步骤,以及常见问题的解决方案。通过硬件准备、软件安装、环境验证和性能优化等环节,帮助开发者高效完成YOLOv8环境配置,提升目标检测项目的开发效率。

defi6farmer的博客 226

修改yolov8使支持单通道图像输入

默认支持BGR三通道图像输入,但是在很多工业场景下,存在很多灰度图像的场景,因此对yolov8代码做一些修改以支持单通道图像输入,满足项目实际需求。训练时,只需要在 data 的 yaml 文件中,添加 ch=1 即可。

mingo_敏 5780

HashMap 1. 7 源码讲解

HashMap 1.7 源码讲解 1、参数讲解 1)hashSeed:用于键的哈希码计算上,用于减少哈希冲突。通过下面所述的initHashSeedAsNeeded方法来进行初始化 2)threshold:表示可以存放的最大量,它的值为loadFactory*数组容量,但是存在最大值为1<<30+1【即2^30+1】 3)loadFactory:负载因子,用于表示元素数量超过数组...

qq_43679056的博客 455

HQChart实战教程64-自定义分时图标题栏

分时图标题栏显示的是当前十字光标所在位置的分钟信息,显示在分时图窗口顶部。一般会显示品种的名称,日期,时间,价格,均价 涨幅,成交量,金额等等,hqchart内置会显示这些信息。如果要额外显示其他的字段,就需要通过替换格式化标题输出函数来是现实。我们在hqchart实例创建完成以后,通过OnCreatedCallback回调函数替换自己的格式化输出函数。返回 { AryText:[ { Text:文字, Color:颜色},…入参 data={ Data: 当前十字光标所在位置的分钟线 }

小银 1057

HashMap底层详细讲解

前面说了扩容机制。那什么时候扩容呢?这就取决于原数组长度和加载因子两个因素了。加载因子也叫扩容因子或负载因子,用来判断什么时候进行扩容的,假如加载因子是 0.5,HashMap 的初始化容量是 16,那么当 HashMap 中有 16*0.5=8 个元素时,HashMap 就会进行扩容。那加载因子为什么是 0.75 而不是 0.5 或者 1.0 呢?这其实是出于容量和性能之间平衡的结果:上面说到,为了提升扩容效率,HashMap 的容量(capacity)有一个固定的要求,那就是一定是 2 的幂。

RanlyRan的博客 1723

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Java源码分析:HashMap 1.8 相对于1.7 到底更新了什么?

Java源码分析:HashMap 1.8 相对于1.7 到底更新了什么? 前言 HashMap 在 Java 和 Android 开发中非常常见 而HashMap 1.8 相对于 HashMap 1.7 更新多 今天,我将通过源码分析HashMap 1.8 ,从而讲解HashMap 1.8 相对于 HashMap 1.7 的更新内容,希望你们会喜欢。 本文基于版本 JDK 1.8,即 J...

y19910825的博客 229

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

【Java集合】HashMap的resize()源码详解以及JDK1.7与JDK1.8的区别

HashMap的扩容源码详解,以及JDK1.7和JDK1.8的resize()方法的源码比较。

小七的博客 2755

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Java集合之HashMap(1.7和1.8)源码分析

Java集合之HashMap 本文将从以下几个方面来理解HashMap: 什么是哈希表 HashMap源码分析 HashMap和HashTable的区别 1.7和1.8有什么区别 哈希表 哈希表是种数据结构,它可以提供快速的插入操作和查找操作。第一次接触哈希表时。不论哈希表中有多少数据,插入和删除(有时包括侧除)只需要接近常量的时间即0(1)的时间级。 为什么哈希这么快呢 首先不得不提哈希函数了( p= H(key) ),哈希函数就是给一个任意大小的数据生成出一个固定长度的数据,作为它的映射 ,这种

全是bug写个蛇的博客 334

(1)美团面试题:Hashmap的结构,1.7和1.8有哪些区别,史上最深入的分析

前言 HashMap 在 Java 和 Android 开发中非常常见 而HashMap 1.8 相对于 HashMap 1.7 更新多 今天,我将通过源码分析HashMap 1.8 ,从而讲解HashMap 1.8 相对于 HashMap 1.7 的更新内容,希望你们会喜欢。 本文基于版本 JDK 1.8,即 Java 8 关于版本 JDK 1.7,即 Java 7,具体请看文章Jav...

M_Jack的博客 671

JDK1.7-HashMap的源码

1.写在前面 前面的Redis的系列的博客已经结束了,今天我打算讲一下HashMap的源码,今天我打算讲一下1.7的HashMap的源码,因为1.7和1.8的源码的变化还是挺大,所以今天我打算讲一下1.7的HashMap的源码,因为1.8的就已经完全不一样了。 2.Map接口 因为HashMap的源码是实现Map的接口,我们平时也都用Map这个接口来接收,所以我们直接看下Map这个接口有哪些方法,具体的如下: public interface Map<K,V> { //获取Map的长度

了不起的盖茨比的博客 618

源码分析:HashMap

大佬讲的贼清晰,看源码清晰多了。 Java:手把手带你源码分析 HashMap 1.7

qq_42956993的博客 112

【面试资料】Java集合篇 之 HashMap

全面解析Java中HashMap的相关知识,包括:实现原理、存储逻辑、扩容机制、常见面试题等内容。

weixin_45306667的博客 1140

面试高频——HashMap

HashMap 是使用频率最高的集合,在面试中也经常会被问到,对于HashMap的学习是通过看源码以及看一些视频的讲解,来加深巩固对这个集合的理解,因为HashMap的内容非常多,涉及的知识点也很多,这篇博客只是整理了一些常见的面试题和列出重要的部分源码,仅供参考! 1. HashMap的底层实现原理 要了解HashMap的底层实现原理,需要先对哈希表有一定的认识,关于哈希表的知识,可以参考上一篇...

can_chen的博客 373

ArrayList、LinkedList、HashMap、HashTable集合源码分析

ArrayList、LinkedList、HashMap、HashTable集合源码分析 JDK1.8和JDK1.7及以下 两个版本中集合类区别还是很大的,所以就按这两个版本来说 一、ArrayList 1.JDK1.8和JDK1.7及以下版本中,ArrayList集合底层都是由数组实现,不同的是默认长度 2.JDK1.8中,在不指定集合长度时,默认长度为0,只有在添加第一个元素的时候,集合长度才会变为10 private static final Object[] DEFAULTCAPACITY_EMPT

qq_36816062的博客 252

知识点二:HashMap 底层的实现过程,在 JDK 1.8 中做了哪些优化?

HashMap 是使用频率最高的类型之一,在 JDK 1.7 中 HashMap 是以数组加链表的形式组成的,JDK 1.8 之后新增了红黑树的组成结构,当链表大于 8 并且容量大于 64 时,链表结构会转换成红黑树结构,它的组成结构如下图所示: 数组中的元素我们称之为哈希桶,它的定义如下: static class Node<K,V> implements Map.Entry&lt...

latata的博客 577

【Java集合】HashMap的put()源码详解以及JDK1.7与JDK1.8的区别

详细讲解HashMap添加操作底层源码,以及对比put()源码在JDK1.7和JDK1.8中的区别。

小七的博客 2834

一文读懂HashMap

本文准备从以下几个方面去讲解HashMap: 1)HashMap源码详细分析 2)HashMap为什么是线程不安全的? 3)HashMap和HashTable的区别 4)1.7和1.8的HashMap实现区别总结 HashMap源码分析 一、构造函数 让我们先从构造函数说起,HashMap有四个构造方法,别慌 1.1 HashMap() // 1.无参构造方法、 // 构造一个空的Hash...

weixin_44997483的博客 191
上一篇: MySQL的三大引擎的特点
下一篇: Linux开关机和目录介绍
code_mzh
博客等级 码龄7年 17粉丝 127原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值