正文

一文就懂hashmap原理！学不会你来砍我！(代码片段)

流楚丶格念  流楚丶格念  2022-10-22  760

关键词：

文章目录

一文就懂HashMap！学不会你来砍我！
1. HashMap 简介
2. HashMap应用
- 2.1 HashMap继承关系
- 2.2 HashMap应用
3. HashMap 源码分析
4. 实际应用

一文就懂HashMap！学不会你来砍我！

首先写这个HashMap的真是很不容易，跟B站上老师学的，然后整理的

上来肯定是先做一个简介了，别着急同志们

1. HashMap 简介

HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null（但是key的位置只能有一个null），此外，HashMap 中的映射不是有序的。

好，我们根据这里的简介看一个入门例子：

package com.hashmap.example;

import java.util.HashMap;

public class StartDemo 
    public static void main(String[] args) 
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("柳岩", 18);
        hashMap.put("杨幂", 28);
        hashMap.put("刘德华", 40);
        // key做null
		hashMap.put(null,33);
        hashMap.put(null,44);
        // value做null
        hashMap.put("玉如梦",null);

        System.out.println(hashMap);

运行结果如下所示：

这里的HashMap我是用的jdk8的，jdk1.7及以前和jdk1.8 及以后的HashMap是有很大区别的：

1.1 jdk1.7与jdk1.8区别

jdk1.7 及之前 HashMap 由 数组 + 链表 组成，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突（两个对象调用的 hashCode 方法计算的哈希值一致导致计算的教组索引值相同）而存在的（“拉链法”解决冲突）。
jdk1.8 及以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（或者红黑树的边界值，默认为 8 ）并且当前数组的长度大于64时，此时此索引位置上的所有数据改为使用红黑树存储。

下面我们说的HashMap都是jdk1.8 及以后的

1.2 链表转化红黑树的条件：

链表转化红黑树的需要满足两个条件：

阈值大于8（阈值：链表上元素个数）
数组长度小于64

将链表转换成红黑树前会判断，即便阈值大于8，但是数组长度小于64，此时并不会将链表变为红黑树，而是选择逬行数组扩容。

这样做的目的是尽量避开红黑树结构。因为数组比较小，这种情况下变为红黑树结构，反而会降低效率，因为红黑树需要逬行左旋，右旋，变色这些操作来保持平衡。同时数组长度小于64时，搜索时间相对要快些。所以结上所述为了提高性能和减少搜索时间，底层阈值大于8并且数组长度大于64时，链表才转换为红黑树，具体可以参考下面的 treeifyBin() 方法。

当然虽然增了红黑树作为底层数据结构，结构变得复杂了，但是阈值大于8并且数组长度大于64时，链表转换为红黑树时，效率也变的更高效。

1.3 小结：

HashMap 特点：

HashMap存储无序的。
键和值位置都可以是 null，但是键位置只能存在一个 null。
键位置是唯一的，是底层的数据结构控制的。
jdk1.8 前数据结构是链表+数组，jdk1.8 之后是链表+数组+红黑树。
阈值（边界值）> 8 并且数组长度大于 64，才将链表转换为红黑树，变为红黑树的目的是为了高效的查询。

2. HashMap 集合底层的数据结构

2. HashMap应用

2.1 HashMap继承关系

HashMap继承关系如下图所示：

解释说明：

Cloneable 空接口，表示可以克隆。创建并返回 HashMap 对象的一个副本。
Serializable 序列化接口。属于标记性接口。HashMap 对象可以被序列化和反序列化。
AbstractMap 父类提供了 Map 实现接口。以最大限度地减少实现此接口所需的工作。

通过上述继承关系，可能会有同学疑惑：AbstractMap is what？HashMap 已经继承了AbstractMap 而 AbstractMap 类实现了Map 接口，那为什么 HashMap 还要在实现 Map 接口呢？同样在 ArrayList 中 LinkedList 中都是这种结构。

首先不用担心，也不用多想！！！我先告诉你，是因为Java创始人写错了。

据 Java 集合框架的创始人 Josh Bloch 描述，这样的写法是一个失误。在 Java 集合框架中，类似这样的写法很多，最幵始写 Java 集合框架的时候，他认为这样写，在某些地方可能是有价值的，直到他意识到错了。显然的，jdk 的维护者，后来不认为这个小小的失误值得去修改，所以就这样保留下来了。

2.2 HashMap应用

HashMap概述与应用可以参考我的另一篇博文：https://blog.csdn.net/weixin_45525272/article/details/125834918

3. HashMap 源码分析

话不多说，先探究一下源码，从中理解下各个函数的原理：

3.1 成员变量

3.1.1 serialVersionUID

首先是序列化版本号：

private static final long serialVersionUID = 362498820763181265L;

它能够保证类在发生合理改动的情况下不会影响对象的反序列化，确保反序列化成功。这个不是HashMap 的特性，这里不赘述了。

3.1.2 DEFAULT_INITIAL_CAPACITY

往下是集合的初始化容量（必须是 2 的 n 次幂）

// 默认的初始容量是16	1 << 4 相当于 1*2的4次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

经过计算：初始容量是16。

那么这就有一个问题了：为什么必须是 2 的 n 次幂？如果输入值不是 2 的幂比如 10 会怎么样?会发生什么？

下面我们来探究一下：

问题：为什么必须是 2 的 n 次幂？如果输入值不是 2 的幂比如 10 不行吗？会发生什么？

首先我们还是要深入源码探究一下，其实HashMap 构造方法还可以指定集合的初始化容量大小：

// 构造一个带指定初始容量和默认负载因子（0.75)的空 HashMap。
HashMap(int initialCapacity)

在源码中我们可以找到对应位置：

根据上述原理我们可以知道，当向 HashMap 中添加一个元素的时候，需要根据 key 的 hash 值，去确定其在数组中的具体位置。HashMap 为了存取高效，减少碰撞，就是要尽量把数据分配均匀，每个链表长度大致相同，这个实现的关键就在把数据存到哪个链表中的算法。

这个算法实际就是取模，hash % length，计算机中直接求余效率不如位移运算。所以源码中做了优化，使用 hash & (length - 1)，而实际上 hash % length 等于 hash & ( length - 1) 的前提是 length 是 2 的 n 次幂。

根据这条定理，例如长度为 8 的时候，3 & (8 - 1) = 3，2 & (8 - 1) = 2，不同位置上，不碰撞。

继续跟进源码，我们发现他调用了另一个构造方法

public HashMap(int initialCapacity, float loadFactor);

前面都是非法的判断，最重要的是最后一句，调用了tableSizeFor方法，然后将返回值给了threshold（容量）

那么我们继续源码，他是这样实现的：

函数说明：当在实例化 HashMap 实例时，如果给定了 initialCapacity，由于 HashMap 的 capacity 必须都是 2 的幂，因此这个方法用于找到大于等于 initialCapacity 的最小的 2 的幂。

/**
* 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;

我们分析一下这个函数的整个流程：

int n = cap - 1;

这里的-1是为了防止 cap 已经是 2 的幂。如果 cap 已经是 2 的幂，又没有这个减 1 操作，则执行完后面的几条无符号操作之后，返回的 capacity 将是这个 cap 的 2 倍。

如果 n 这时为 0 了（经过了cap - 1后），则经过后面的几次无符号右移依然是 0，最后返回的 capacity 是1（最后有个 n + 1 的操作）。
注意：容量最大也就是 32bit 的正数，因此最后 n |= n >>> 16; 最多也就 32 个 1（但是这已经是负数了，在执行 tableSizeFor 之前，对 initialCapacity 做了判断，如果大于MAXIMUM_CAPACITY(2 ^ 30)，则取 MAXIMUM_CAPACITY。如果等于MAXIMUM_CAPACITY，会执行位移操作。所以这里面的位移操作之后，最大 30 个 1，不会大于等于 MAXIMUM_CAPACITY。30 个 1，加 1 后得 2 ^ 30）。

再拿刚才说的初始值为10试一试：：

注意：得到的这个 capacity 却被赋值给了 threshold。

this.threshold = tableSizeFor(initialCapacity);

最后计算得到16，然后把16返回给了threshold，所以如果是容量设置为10的话，他也会自动计算为16。

这里就有同学会问了，threshold不是等于 Capacity*loadFactor吗？

问题：threshold不是等于 Capacity*loadFactor吗？这里为什么直接返回了？

在jdk8以后的构造方法中，并没有对table这个成员变量进行初始化，table的初始化被推迟到了put方法中，在put方法中会对threshold重新计算。

下面看put源码时，你会得到相应的答案。不慌不慌

3.1.3 DEFAULT_LOAD_FACTOR

再往下是默认的负载因子（默认值 0.75）

static final float DEFAULT_LOAD_FACTOR = 0.75f;

3.1.4 MAXIMUM_CAPACITY

集合最大容量：2³⁰

static final int MAXIMUM_CAPACITY = 1 << 30; // 2的30次幂

3.1.5 TREEIFY_THRESHOLD

当链表的值超过8则会转为红黑树（jdk1.8新增）

// 当桶（bucket）上的结点数大于这个值时会转为红黑树
static final int TREEIFY_THRESHOLD = 8;

问题：为什么 Map 桶中结点个数超过 8 才转为红黑树？

8这个阈值定义在HashMap中，针对这个成员变量，在源码的注释中只说明了 8 是 bin（bin就是 bucket 桶）从链表转成树的阈值，但是并没有说明为什么是 8。

在 HashMap 中有一段注释说明：

Because TreeNodes are about twice the size of regular nodes, we use them only when bins
contain enough nodes to warrant use (see TREEIFY_THRESHOLD). And when they become too
small (due to removal or resizing) they are converted back to plain bins.  In usages with
well-distributed user hashCodes, tree bins are rarely used.  Ideally, under random hashCodes, 
the frequency of nodes in bins follows a Poisson distribution 
(http://en.wikipedia.org/wiki/Poisson_distribution) 
with a parameter of about 0.5 on average for the default resizing
threshold of 0.75, although with a large variance because of resizing granularity. Ignoring variance, 
the expected occurrences of list size k are (exp(-0.5) * pow(0.5, k) / factorial(k)). The first values are:

翻译：因为树结点的大小大约是普通结点的两倍，所以我们只在箱子包含足够的结点时才使用树结点(参见TREEIFY_THRESHOLD)。
当它们变得太小（由于删除或调整大小）时，就会被转换回普通的桶。在使用分布良好的用户 hashCode 时，很少使用树箱。
理想情况下，在随机哈希码下，箱子中结点的频率服从泊松分布
(http://en.wikipedia.org/wiki/Poisson_distribution) ，默认调整阈值为0.75，平均参数约为0.5，尽管由 
于调整粒度的差异很大。忽略方差，列表大小k的预朗出现次数是(exp(-0.5) * pow(0.5, k) / factorial(k))。 
第一个值是：

0:    0.60653066
1:    0.30326533
2:    0.07581633
3:    0.01263606
4:    0.00157952
5:    0.00015795
6:    0.00001316
7:    0.00000094
8:    0.00000006
more: less than 1 in ten million

TreeNodes 占用空间是普通 Nodes 的两倍，所以只有当 bin 包含足够多的结点时才会转成 TreeNodes，而是否足够多就是由 TREEIFY_THRESH〇LD 的值决定的。当 bin 中结点数变少时，又会转成普通的 bin。并且我们查看源码的时候发现，链表长度达到 8 就转成红黑树，当长度降到 6 就转成普通 bin。

这样就解释了为什么不是一开始就将其转换为 TreeNodes，而是需要一定结点数才转为 TreeNodes，说白了就是权衡空间和时间。

这段内容还说到：当 hashCode 离散性很好的时候，树型 bin 用到的概率非常小，因为数据均匀分布在每个 bin 中，几乎不会有 bin 中链表长度会达到阈值。但是在随机 hashCode 下，离散性可能会变差，然而 jdk 又不能阻止用户实现这种不好的 hash 算法，因此就可能导致不均匀的数据分布。不理想情况下随机 hashCode 算法下所有 bin 中结点的分布频率会遵循泊松分布，我们可以看到，一个 bin 中链表长度达到 8 个元素的槪率为 0.00000006，几乎是不可能事件。所以，之所以选择 8，不是随便決定的，而是裉据概率统计决定的。甶此可见，发展将近30年的 Java 每一项改动和优化都是非常严谨和科学的。

也就是说：选择 8 因为符合泊松分布，超过 8 的时候，概率已经非常小了，所以我们选择 8 这个数宇。

补充：

Poisson 分布（泊松分布），是一种统计与概率学里常见到的离散[概率分布]。泊松分布的概率函数为：

泊松分布的参数 A 是单位时间（或单位面积）内随机事件的平均发生次数。泊松分布适合于描述单位时间内随机事件发生的次数。

也可以从查找的时间复杂度去解析：
红黑树的平均查找长度是 log(n)，如果长度为 8，平均查找长度为 log(8) = 3，链表的平均查找长度为 n/2，当长度为 8 时，平均查找长虔为 8/2 = 4，这才有转换成树的必要；链表长度如果是小于等于 6， 6/2 = 3，而 log(6) = 2.6，虽然速度也很快的，但是转化为树结构和生成树的时间并不会太短。

3.1.6 UNTREEIFY_THRESHOLD

当链表的值小于 6 则会从红黑树转回链表

// 当桶（bucket）上的结点数小于这个值，树转为链表 
static final int UNTREEIFY_THRESHOLD = 6;

3.1.7 MIN_TREEIFY_CAPACITY

当 Map 里面的数量超过这个值时，表中的桶才能进行树形化，否则桶内元素太多时会扩容，而不是树形化为了避免进行扩容、树形化选择的冲突，这个值不能小于4*TREEIFY_THRESHOLD(8)

// 桶中结构转化为红黑树对应的数组长度最小的值 
static final int MIN_TREEIFY_CAPACITY = 64;

3.1.8 table

table 用来初始化（必须是二的n次幂）(重点)

// 存储元素的数组 
transient Node<K,V>[] table;

在 jdk1.8 中我们了解到 HashMap 是由数组加链表加红黑树来组成的结构，其中 table 就是 HashMap 中的数组，jdk8 之前数组类型是 Entry<K,V> 类型。从 jdk1.8 之后是 Node<K,V> 类型。

其实吧：它也只是换了个名字，都实现了一样的接口：Map.Entry<K,V>。

Map.Entry<K,V>就是负责存储键值对数据的

3.1.9 entrySet

用来存放缓存

// 存放具体元素的集合
transient Set<Map.Entry<K,V>> entrySet;

3.1.10 size

HashMap 中存放元素的个数(重点)

// 存放元素的个数，注意这个不等于数组的长度
 transient int size;

size 为 HashMap 中 K-V 的实时数量，不是数组 table 的长度。

注意：这里的size是实际个数，和容量不一样，比如说：容量为16，里面只存了“1”,1，“2”,2两个元素，那么他的size是2，table 的长度还是16，所以最后size可能会比数组长度大的。

3.1.11 modCount

用来记录 HashMap 的修改次数

// 每次扩容和更改 map 结构的计数器
 transient int modCount;

3.1.12 threshold

用来调整大小下一个容量的值计算方式为（容量*负载因子）

// 临界值 当实际大小（容量*负载因子）超过临界值时，会进行扩容
int threshold;

3.1.13 loadFactor

哈希表的负载因子(重点)

// 负载因子
final float loadFactor;

探究：容量&负载因子

loadFactor 是用来衡量 HashMap 满的程度，表示HashMap的疏密程度，影响 hash 操作到同一个数组位置的概率，计算 HashMap 的实时负载因子的方法为：size/capacity，而不是占用桶的数量去除以 capacity。capacity 是桶的数量，也就是 table 的长度 length。
loadFactor 太大导致查找元素效率低，太小导致数组的利用率低，存放的数据会很分散。loadFactor 的默认值为 0.75f 是官方给出的一个比较好的临界值。
当 HashMap 里面容纳的元素已经达到 HashMap 数组长度的 75% 时，表示 HashMap 太挤了，需要扩容，而扩容这个过程涉及到 rehash、复制数据等操作，非常消耗性能。所以开发中尽量减少扩容的次数，可以通过创建 HashMap 集合对象时指定初始容量来尽量避免。
在 HashMap 的构造器中可以定制 loadFactor。

// 构造方法，构造一个带指定初始容量和负载因子的空HashMap
HashMap(int initialCapacity, float loadFactor);

比如下面代码：

HashMap<String, Integer> map = new HashMap<>(16,0.8f);

为什么负载因子设置为0.75，初始化临界值是12？

loadFactor 越趋近于1，那么数组中存放的数据(entry)也就越多，也就越密，也就是会让链表的长度增加，loadFactor 越小，也就是趋近于0，数组中存放的数据(entry)也就越少，也就越稀疏。

如果希望链表尽可能少些，要提前扩容。有的数组空间有可能一直没有存储数据，负载因子尽可能小一些。

举例：

例如：负载因子是0.4。 那么16*0.4--->6 如果数组中满6个空间就扩容会造成数组利用率太低了。
	 负载因子是0.9。 那么16*0.9--->14 那么这样就会导致链表有点多了，导致查找元素效率低。

所以既兼顾数组利用率又考虑链表不要太多，经过大量测试 0.75 是最佳方案。

threshold 计算公式：capacity(数组长度默认16) * loadFactor(负载因子默认0.75)。

这个值是当前已占用数组长度的最大值。当 Size >= threshold 的时候，那么就要考虑对数组的 resize(扩容)，也就是说，这个的意思就是 衡量数组是否需要扩增的一个标准。扩容后的 HashMap 容量是之前容量的两倍。

3.2 构造方法

HashMap 中重要的构造方法，它们分别如下：

3.2.1 HashMap()

构造一个空的HashMap，默认初始容量（16）和默认负载因子（0.75）。

public HashMap() 
   this.loadFactor = DEFAULT_LOAD_FACTOR; // 将默认的负载因子0.75赋值给loadFactor，并没有创建数组

3.2.2 HashMap(int initialCapacity)

构造一个具有指定的初始容量和默认负载因子（0.75）HashMap 。

// 指定“容量大小”的构造函数
public HashMap(int initialCapacity) 
    this(initialCapacity, DEFAULT_LOAD_FACTOR);

3.2.3 HashMap(int initialCapacity, float loadFactor)

构造一个具有指定的初始容量和负载因子的 HashMap。

/*
	 指定“容量大小”和“负载因子”的构造函数
	 initialCapacity：指定的容量
	 loadFactor:指定的负载因子
*/
public HashMap(int initialCapacity, float loadFactor) 
    	// 判断初始化容量initialCapacity是否小于0
        if (initialCapacity < 0)
            // 如果小于0，则抛出非法的参数异常IllegalArgumentException
            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
    	// 判断初始化容量initialCapacity是否大于集合的最大容量MAXIMUM_CAPACITY
        if (initialCapacity > MAXIMUM_CAPACITY)
            // 如果超过MAXIMUM_CAPACITY，会将MAXIMUM_CAPACITY赋值给initialCapacity
            initialCapacity = MAXIMUM_CAPACITY;
    	// 判断负载因子loadFactor是否小于等于0或者是否是一个非数值
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            // 如果满足上述其中之一，则抛出非法的参数异常IllegalArgumentException
            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
     	// 将指定的负载因子赋值给HashMap成员变量的负载因子loadFactor
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    
	
	// 最后调用了tableSizeFor，来看一下方法实现：
     /*
     	返回比指定初始化容量大的最小的2的n次幂
     */
    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;

说明：

对于 javathis.threshold = tableSizeFor(initialCapacity); 疑问解答：

tableSizeFor(initialCapacity)判断指定的初始化容量是否是2的n次幂，如果不是那么会变为比指定初始化容量大的最小的2的n次幂。
但是注意，在tableSizeFor方法体内部将计算后的数据返回给调用这里了，并且直接赋值给threshold边界值了。有些人会觉得这里是一个bug，应该这样书写：
this.threshold = tableSizeFor(initialCapacity) * this.loadFactor;
这样才符合threshold的意思（当HashMap的size到达threshold这个阈值时会扩容）。
但是请注意，在jdk8以后的构造方法中，并没有对table这个成员变量进行初始化，table的初始化被推迟到了put方法中，在put方法中会对threshold重新计算。

3.2.4 HashMap(Map<? extends K, ? extends V> m)

包含另一个 “Map” 的构造函数，比如说

package com.hashmap.example;

import java.util.HashMap;
import java.util.*;

public class StartDemo 
    public static void main(String[] args) 
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("柳岩", 18);
        HashMap<String, Integer> map = new HashMap<>(hashMap);
        System.out.println();

此时就会调用这个构造函数，我们来看一下源码：

// 构造一个映射关系与指定 Map 相同的新 HashMap。
public HashMap(Map<? extends K, ? extends V> m) 
    	// 负载因子loadFactor变为默认的负载因子0.75
         this.loadFactor = DEFAULT_LOAD_FACTOR;
         putMapEntries(m, false);

首先它将负载因子loadFactor变为默认的负载因子0.75，

最后调用了 putMapEntries()，好了，这个肯定是重点了，我们跟进一下源码，来看一下方法实现：

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) 
    //获取参数集合的长度
    int s = m.size();
    if (s > 0) 
        //判断参数集合的长度是否大于0，说明大于0
        if (table == null)  // 判断table是否已经初始化
                // 未初始化，s为m的实际元素个数
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY);
                // 计算得到的t大于阈值，则初始化阈值
                if (t > threshold)
                    threshold = tableSizeFor(t);
        
        // 已初始化，并且m元素个数大于阈值，进行扩容处理
        else if (s > threshold)
            resize();
        // 将m中的所有元素添加至HashMap中
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) 
            K key = e.getKey(查看详情  
                
java的垃圾回收机制详解——从入门到出土，学不会接着来砍我！
文章目录哪些内存需要回收回收堆：垃圾的定义引用计数算法：可达性分析算法：GCRoots的对象回收方法区：垃圾的定义如何回收垃圾垃圾回收算法总结标记—清除算法（适用老年代，但是基本废弃了）...  查看详情  
                
springboot2从入门到入坟|web场景开发篇：超硬核两万四千多字，全网最详细源码分析之静态资源配置原理，不是你来砍我
目录一览写在前面静态资源配置原理`WebMvcAutoConfiguration`自动配置类的详细分析是否生效？给容器中配了什么？揭秘`WebMvcAutoConfigurationAdapter`配置类揭秘`EnableWebMvcConfiguration`配置类资源处理的默认规则禁用所有静态资源配置规则源...  查看详情  
                
一文就懂concurrenthashmap实现原理(代码片段)
文章目录ConcurrentHashMap介绍补：ConcurrentHashMap与HashMap等的区别ConcurrentHashMap实现原理JDK1.7版本实现原理Segment(分段锁)内部结构JDK1.7原理结构的优缺点JDK1.8版本实现原理CASNodeJDK1.7与1.8区别总结JDK1.7ConcurrentHashMap源码分析成员变量...  查看详情  
                
一文就懂concurrenthashmap实现原理(代码片段)
文章目录ConcurrentHashMap介绍补：ConcurrentHashMap与HashMap等的区别ConcurrentHashMap实现原理JDK1.7版本实现原理Segment(分段锁)内部结构JDK1.7原理结构的优缺点JDK1.8版本实现原理CASNodeJDK1.7与1.8区别总结JDK1.7ConcurrentHashMap源码分析成员变量...  查看详情  
                
java的垃圾回收机制详解——从入门到出土，学不会接着来砍我！
文章目录哪些内存需要回收回收堆：垃圾的定义引用计数算法：可达性分析算法：GCRoots的对象回收方法区：垃圾的定义如何回收垃圾垃圾回收算法总结标记—清除算法（适用老年代，但是基本废弃了）...  查看详情  
                
十大经典排序算法(代码片段)
...演示；这还不够，我还附上了对应的优质文章，看完不懂你来砍我，如果不想砍我就给我来个好看。术语解释有些人可能不知道什么是稳定排序、原地排序、时间复杂度、空间复杂度，我这里先简单解释一下：1、稳定排序：如...  查看详情  
                
最全goselect底层原理，一文学透高频用法(代码片段)
导语|在日常开发中，select语句被高频使用。但目前，全网分析select在编译期和运行时的完整底层原理资料，非常匮乏。本文基于Go1.18.1版本的源码，讲解select访问Channel在编译期和运行时的底层原理——select编译器...  查看详情  
                
hashmap一问一答(代码片段)
参考博文一文读懂HashMap，深入浅出学Java——HashMap上面两篇文章介绍的jdk1.7的hashmap实现与原理，写得十分清楚，建议阅读。在写了几篇随笔后，发现我只是阐述原理，却没有认真细下心来分析为什么要这样做，这样做有哪些好...  查看详情  
                
学python不会matplotlib是什么？一文教你入门matplotlib(代码片段)
前言：作者：神的孩子在跳舞本人是刚开始学机器学习的小白，以下都是我的学习笔记，有一些是我自己理解的话，所以可能有不对的地方或者有些话只适合我自己理解（仅供参考），不对的希望...  查看详情  
                
一文就懂aqs！(代码片段)
文章目录AQS介绍AQS概念AQS模式分类AQS核心思想AQS源码结构CLH同步队列state同步状态独占式同步状态获取与释放流程图总结：共享式同步状态获取与释放看了很多帖子，原理说啥的都有，算了还是自己整理吧，既然...  查看详情  
                
作为java开发，知道hashmap底层存储原理总不会害你！
HashMap底层存储原理概念存储的优点HashMap存储元素的过程HashMap取值的实现扩容HashMap中的扩容是在元素插入之前进行的扩容还是元素插入之后进行的扩容存储元素超过阈...  查看详情  
                
hashmap(代码片段)
前言　　在我们开发中，HashMap是我们非常常用的数据结构，接下来我将进一步去了解HashMap的原理、结构。1、HashMap的实现原理　　HashMap底层是基于Hash表（也称“散列”）的数据结构实现的，由数组和链表组成，数组是Hash...  查看详情  
                
hashmap源码详解(一文掌握所有核心知识)(代码片段)
大纲前言HashMap解决了什么问题查询速率不高的问题哈希冲突自动扩容从put()方法开始了解源码resize()实现扩容的关键(e.hash&oldCap)==0到底是什么？split()扩容时对红黑树的处理关于红黑树的最少必要知识红黑树插入后保...  查看详情  
                
java8新特性，你一定能学会的超详细保姆级源码笔记，看完还不会请直接砍我(代码片段)
1.新特性简介新特性简介速度更快代码更少：新增了Lambda表达式强大的StreamAPI便于并行最大化减少空指针异常Optional2.Lambda表达式介绍Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码...  查看详情  
                
一文看懂hashmap(代码片段)
一文看懂HashMap总所周知HashMap是面试中经常问到的一个知识点，也是判断一个候选人基础是否扎实的标准之一，因为通过HashMap可以引出很多知识点，比如数据结构(数组、链表、红黑树)、equals和hashcode方法，除此之外还可以引出...  查看详情  
                
小白都能看得懂的教程看完这篇还不会生成随机验证码图片，你来打我！！！(代码片段)
小白都能看得懂的教程一文教你实现生成随机图像验证码大家好，我叫亓官劼（qíguānjié），三本计算机在读，目前在积极准备21计算机考研中，同时也在学习后端开发，准备工作。不敢孤注一掷，...  查看详情  
                
rabbitmq！女朋友看了都会的超详细保姆级附源码笔记！看完还不会请砍我！(代码片段)
1.MQ1.1MQ的相关概念什么是MQMQ(messagequeue)，从字面意思上看，本质是个队列，FIFO先入先出，只不过队列中存放的内容是message而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中,MQ是一...  查看详情