热门标签
热门文章
- 1【Python】在windows上利用vscode搭建Python编程环境_vscode创建python项目
- 2计算机顶会举办时间地点速查（参考文献引用）——ECCV_european conference on computer vision上面的文章引用格式
- 3电池荷电状态估计SOC？电池管理系统_荷电状态soc计算方法
- 4Ubuntu设置xshell远程root用户登陆_ubuntu20开启xshell远程登录
- 5使用 Dashscope 和通义千问进行多模态对话和图像识别_dashscope 函数调用
- 6FPS透视自瞄基本概念_易语言自瞄的算法是怎么算的
- 7探索 Dify：开源 LLM 应用开发平台_flowise dify
- 8图神经网络 | (2) 图神经网络(Graph Neural Networks,GNN)综述_t2-gnn: graph neural networks for graphs with inco
- 9Multiprocessing之Pool类的简单解读，看了就能使用_multiprocessing pool
- 10QCustomPlot开源库使用_qcustomplot保存矢量图
当前位置: article > 正文
java集合-HashMap源码详解（jdk1.8）_java1.8 map原码
作者：煮酒与君饮 | 2024-07-28 07:42:46
赞
踩
java1.8 map原码
前言
hashmap是什么？
HashMap采用key/value存储结构，每个key对应唯一的value，查询和修改能达到O(1)的平均时间复杂度。其为非线程安全的，且不保证元素存储的顺序
一、继承体系和存储结构
Question:
-
- 为什么在jdk1.8改为了“数组+链表+红黑树”的存储结构？
-
- 什么条件下做树化？反树化呢？
-
- hashmap有哪些属性？各个属性的表示的是什么？
-
- 为什么容量是2的整数幂？
继承体系
Cloneable接口说明hashmap对象可复制
Serializable接口说明其对象可序列化
实现了Map接口并继承了AbstractMap抽象类（实现了Map接口诸多函数）
存储结构
jdk1.8的hashmap采用的存储结构是“数组+链表+红黑树”，如下图：
因为在jdk1.7中，当数据量很大时（hash冲突严重）会造成链表的长度很长，查询的时间复杂度为O(n),而红黑树的查询的时间复杂度为O(logn),提升了性能。（问题一）。
当数组table(图中)的长度大于64并且链表的长度超过了8个结点，则进行树化（链表转化为红黑树），倘若数组长度小与64，链表也超过了8个结点，只需进行数组扩容即可（扩容后链表长度减少），当同一个索引位置的节点在移除后达到 6 个，并且该索引位置的节点为红黑树节点，会触发红黑树节点转链表结点。（问题二）
下面让我们看一下源码：
/** * 默认的初始容量为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; /** * 当一个桶中的元素个数大于等于8时进行树化 */ static final int TREEIFY_THRESHOLD = 8; /** * 当一个桶中的元素个数小于等于6时把树转化为链表 */ static final int UNTREEIFY_THRESHOLD = 6; /** * 当桶的个数达到64的时候才进行树化 */ static final int MIN_TREEIFY_CAPACITY = 64; /** * 数组 */ transient Node<K,V>[] table; /** * 作为entrySet()的缓存，存放元素的集合 */ transient Set<Map.Entry<K,V>> entrySet; /** * 元素的数量 */ transient int size; /** * 修改次数，用于在迭代的时候执行快速失败策略 */ transient int modCount; /** * 当桶的使用数量达到多少时进行扩容(扩容阈值） */ int threshold; /** * 装载因子 */ final float loadFactor;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
（问题三）
hashmap容量只能是2的整数次幂，如果使用无参构造函数，默认容量为16，倘若采用有参构造函数，会将大于参数的最近2的整数幂作为容量。函数如下：
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;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
此外：在putVal()函数中（增加结点的函数）通过（n-1）（n为数组长度）&hash(key的哈希值)来计算key的散列地址的。这里使用与运算取代了%（前者效率更高），但替换条件是n为2的n次方。（问题四）.
结点源码Node<>和TreeNode<>
Node<>
Node是一个典型的单链表节点，其中，hash用来存储key计算得来的hash值。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
- 1
- 2
- 3
- 4
- 5
- 6
TreeNode
TreeNode是一个典型的树型节点，其中，prev是链表中的节点，用于在删除元素的时候可以快速找到它的前置节点。
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { TreeNode<K,V> parent; // red-black tree links TreeNode<K,V> left; TreeNode<K,V> right; TreeNode<K,V> prev; // needed to unlink next upon deletion boolean red; } // 位于LinkedHashMap中，典型的双向链表节点 static class Entry<K,V> extends HashMap.Node<K,V> { Entry<K,V> before, after; Entry(int hash, K key, V value, Node<K,V> next) { super(hash, key, value, next); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
二、主要函数的剖析
put()
功能：添加元素的接口
在分析源码之前理解一下整个的添加元素的思路,随后再看一下源码如何体现的。
- 计算key对应hash值
- if数组大小为空或者为0，调用resize()进行数组的初始化
- 计算得到key对应的桶的位置
- 判断桶是否为null
- 为null,则直接添加结点到该位置,
- 不为null,则判断该桶位置首结点是树节点还是链表结点
- 树节点则按照红黑树添加元素方式，链表则遍历结点查看是否有相同key值的结点
- 若链表中有相同key则再根据传入参数判断是否更换value,无相同则在链尾加结点并判断是否要树化。
- size++,判断是否要扩容
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } //put调用函数 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; //判断数组大小为空或者为0，是则调用resize()进行数组的初始化 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 { //不为空，则判断待添加元素和该位置的结点hash值和key值是否相同 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);//是红黑树，则调用增加树结点的函数putTreeVal() else {//是链表，则进行链表的遍历 for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) {// 如果在链表中没有找到相同key的元素，则在链表尾端添加元素，添加后检测是否需要树化 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))))//在链表中找到相同key值的元素，直接停止遍历即可 break; p = e; } } if (e != null) { // 这个if语句在存在相同key情况（e==null说明未找到相同key值的结点）下，根据参数onlyIfAbsent来判断是否需要更换value值 V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount;//操作数增加 if (++size > threshold)//如果增加后元素个数大于阈值，则调用resize()扩容 resize(); afterNodeInsertion(evict); return null; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
resize()
功能：扩容函数
逻辑：
- 判断是容量是否为0（区别了是否是刚初始化的，刚初始化的数组的引用为null）
- 不为0，则如果容量大于等于最大容量，则不进行扩容，阈值更改为最大。容量小与最大容量，则在最大容量范围内扩大到原容量两倍。
- 为0(初始化有无参构造和有参构造），判断原阈值是否大于0，大于0（有参构造）则将原阈值赋值给新容量，否则（无参构造）新容量和新阈值均采用默认值（其实这一步是根据你采用的构造方法决定的）
- 如果新阈值为0（有参构造），则将根据新容量和装载因子来计算新阈值。
- 建立新容量数组
- 如果旧数组为null,说明无需进行元素的重新排列，否则需要重新排列扩容后的元素。
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) // 如果旧容量的两倍小于最大容量并且旧容量大于默认初始容量（16），则容量扩大为两部，扩容门槛也扩大为两倍 newThr = oldThr << 1; // double threshold } else if (oldThr > 0) // initial capacity was placed in threshold // 使用非默认构造方法，如果旧容量为0且旧扩容门槛大于0，则把新容量赋值为旧门槛 newCap = oldThr; else { // zero initial threshold signifies using defaults // 调用默认构造方法创建的 newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } if (newThr == 0) { // 如果新扩容门槛为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; // 如果桶中第一个元素不为空，赋值给e if ((e = oldTab[j]) != null) { // 清空旧桶，便于GC回收 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 // 如果这个链表不止一个元素且不是一颗树 // 则分化成两个链表插入到新的桶中去 // 比如，假如原来容量为4，3、7、11、15这四个元素都在三号桶中 // 现在扩容到8，则3和11还是在三号桶，7和15要搬移到七号桶中去 // 也就是分化成了两个链表 Node<K, V> loHead = null, loTail = null; Node<K, V> hiHead = null, hiTail = null; Node<K, V> next; do { next = e.next; // (e.hash & oldCap) == 0的元素放在低位链表中 // 比如，3 & 4 == 0 if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { // (e.hash & oldCap) != 0的元素放在高位链表中 // 比如，7 & 4 != 0 if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); // 遍历完成分化成两个链表了 // 低位链表在新桶中的位置与旧桶一样（即3和11还在三号桶中） if (loTail != null) { loTail.next = null; newTab[j] = loHead; } // 高位链表在新桶中的位置正好是原来的位置加上旧容量（即7和15搬移到七号桶了） if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
putTreeVal(…)
功能：往红黑树中添加元素
逻辑：
（1）寻找根节点；
（2）从根节点开始查找；
（3）比较hash值及key值，如果都相同，直接返回，在putVal()方法中决定是否要替换value值；
（4）根据hash值及key值确定在树的左子树还是右子树查找，找到了直接返回；
（5）如果最后没有找到则在树的相应位置插入元素，并做平衡
final TreeNode<K, V> putTreeVal(HashMap<K, V> map, Node<K, V>[] tab, int h, K k, V v) { Class<?> kc = null; // 标记是否找到这个key的节点 boolean searched = false; // 找到树的根节点 TreeNode<K, V> root = (parent != null) ? root() : this; // 从树的根节点开始遍历 for (TreeNode<K, V> p = root; ; ) { // dir=direction，标记是在左边还是右边 // ph=p.hash，当前节点的hash值 int dir, ph; // pk=p.key，当前节点的key值 K pk; if ((ph = p.hash) > h) { // 当前hash比目标hash大，说明在左边 dir = -1; } else if (ph < h) // 当前hash比目标hash小，说明在右边 dir = 1; else if ((pk = p.key) == k || (k != null && k.equals(pk))) // 两者hash相同且key相等，说明找到了节点，直接返回该节点 // 回到putVal()中判断是否需要修改其value值 return p; else if ((kc == null && // 如果k是Comparable的子类则返回其真实的类，否则返回null (kc = comparableClassFor(k)) == null) || // 如果k和pk不是同样的类型则返回0，否则返回两者比较的结果 (dir = compareComparables(kc, k, pk)) == 0) { // 这个条件表示两者hash相同但是其中一个不是Comparable类型或者两者类型不同 // 比如key是Object类型，这时可以传String也可以传Integer，两者hash值可能相同 // 在红黑树中把同样hash值的元素存储在同一颗子树，这里相当于找到了这颗子树的顶点 // 从这个顶点分别遍历其左右子树去寻找有没有跟待插入的key相同的元素 if (!searched) { TreeNode<K, V> q, ch; searched = true; // 遍历左右子树找到了直接返回 if (((ch = p.left) != null && (q = ch.find(h, k, kc)) != null) || ((ch = p.right) != null && (q = ch.find(h, k, kc)) != null)) return q; } // 如果两者类型相同，再根据它们的内存地址计算hash值进行比较 dir = tieBreakOrder(k, pk); } TreeNode<K, V> xp = p; if ((p = (dir <= 0) ? p.left : p.right) == null) { // 如果最后确实没找到对应key的元素，则新建一个节点 Node<K, V> xpn = xp.next; TreeNode<K, V> x = map.newTreeNode(h, k, v, xpn); if (dir <= 0) xp.left = x; else xp.right = x; xp.next = x; x.parent = x.prev = xp; if (xpn != null) ((TreeNode<K, V>) xpn).prev = x; // 插入树节点后平衡 // 把root节点移动到链表的第一个节点 moveRootToFront(tab, balanceInsertion(root, x)); return null; } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
treeifyBin()
功能：链表长度大于等于8后判断是否需要树化
final void treeifyBin(Node<K, V>[] tab, int hash) { int n, index; Node<K, V> e; //如果桶数量小于64，直接扩容而不用树化 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize();//选择扩容 else if ((e = tab[index = (n - 1) & hash]) != null) { TreeNode<K, V> hd = null, tl = null; do {//遍历换成树节点 TreeNode<K, V> p = replacementTreeNode(e, null); if (tl == null) hd = p; else { p.prev = tl; tl.next = p; } tl = p; } while ((e = e.next) != null); if ((tab[index] = hd) != null) hd.treeify(tab);//树化函数 } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
treeify()
功能：树化函数
逻辑:
（1）从链表的第一个元素开始遍历；
（2）将第一个元素作为根节点；
（3）其它元素依次插入到红黑树中，再做平衡；
（4）将根节点移到链表第一元素的位置（因为平衡的时候根节点会改变）；
final void treeify(Node<K, V>[] tab) { TreeNode<K, V> root = null; for (TreeNode<K, V> x = this, next; x != null; x = next) { next = (TreeNode<K, V>) x.next; x.left = x.right = null; // 第一个元素作为根节点且为黑节点，其它元素依次插入到树中再做平衡 if (root == null) { x.parent = null; x.red = false; root = x; } else { K k = x.key; int h = x.hash; Class<?> kc = null; // 从根节点查找元素插入的位置 for (TreeNode<K, V> p = root; ; ) { int dir, ph; K pk = p.key; if ((ph = p.hash) > h) dir = -1; else if (ph < h) dir = 1; else if ((kc == null && (kc = comparableClassFor(k)) == null) || (dir = compareComparables(kc, k, pk)) == 0) dir = tieBreakOrder(k, pk); // 如果最后没找到元素，则插入 TreeNode<K, V> xp = p; if ((p = (dir <= 0) ? p.left : p.right) == null) { x.parent = xp; if (dir <= 0) xp.left = x; else xp.right = x; // 插入后平衡，默认插入的是红节点，在balanceInsertion()方法里 root = balanceInsertion(root, x); break; } } } } // 把根节点移动到链表的头节点，因为经过平衡之后原来的第一个元素不一定是根节点了 moveRootToFront(tab, root); }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
get(Object key)
功能：获取key对应的value
逻辑：
1）计算key的hash值；
（2）找到key所在的桶及其第一个元素；
（3）如果第一个元素的key等于待查找的key，直接返回；
（4）如果第一个元素是树节点就按树的方式来查找，否则按链表方式查找；
public V get(Object key) { Node<K, V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K, V> getNode(int hash, Object key) { Node<K, V>[] tab; Node<K, V> first, e; int n; K k; // 如果桶的数量大于0并且待查找的key所在的桶的第一个元素不为空 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 TreeNode) return ((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; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
getTreeNode(int h, Object k)
功能：根据hash值查找元素
final TreeNode<K, V> getTreeNode(int h, Object k) { // 从树的根节点开始查找 return ((parent != null) ? root() : this).find(h, k, null); } final TreeNode<K, V> find(int h, Object k, Class<?> kc) { TreeNode<K, V> p = this; do { int ph, dir; K pk; TreeNode<K, V> pl = p.left, pr = p.right, q; if ((ph = p.hash) > h) // 左子树 p = pl; else if (ph < h) // 右子树 p = pr; else if ((pk = p.key) == k || (k != null && k.equals(pk))) // 找到了直接返回 return p; else if (pl == null) // hash相同但key不同，左子树为空查右子树 p = pr; else if (pr == null) // 右子树为空查左子树 p = pl; else if ((kc != null || (kc = comparableClassFor(k)) != null) && (dir = compareComparables(kc, k, pk)) != 0) // 通过compare方法比较key值的大小决定使用左子树还是右子树 p = (dir < 0) ? pl : pr; else if ((q = pr.find(h, k, kc)) != null) // 如果以上条件都不通过，则尝试在右子树查找 return q; else // 都没找到就在左子树查找 p = pl; } while (p != null); return null; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
参考文章：链接
推荐学习网站：java驿站
欢迎指正交流学习哈~
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/893300
推荐阅读
相关标签
