> entrySet;
/**
* 包含的键值映射的数量。
*/
transient int size;
/**
*
* modCount便是hashmap结构修改的次数。
* 在之前对iterator（迭代器）进行讲解的时候我已经进行了说明，
* 需要注意的是在hashmap中modcount指的是结构更改的次数，例如添加新的node，
* 但是如果是替换原有node的value，modcount是不变的，因为它不属于结构变化。
*
*/
transient int modCount;
/**
* threshold是hashmap所能容纳的最大数据量的Node个数，
* 默认为0.75，threshold=DEFAULT_INITIAL_CAPACITY*loadFactor;当添加元素数量超过这个数量过后，就要进行扩容，扩容后hashmap的容量是之前的两倍
*/
int threshold;
/**
* The load factor for the hash table.
*
* @serial
*/
final float loadFactor;
/* ---------------- Public operations -------------- */
/**
* Constructs an empty HashMap 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 > MapUtilConst.MAXIMUM_CAPACITY)
initialCapacity = MapUtilConst.MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
/**
* Constructs an empty HashMap 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, MapUtilConst.DEFAULT_LOAD_FACTOR);
}
/**
* Constructs an empty HashMap with the default initial capacity (16)
* and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = MapUtilConst.DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
* Constructs a new HashMap with the same mappings as the specified
* Map. The HashMap is created with default load factor (0.75)
* and an initial capacity sufficient to hold the mappings in the specified
* Map.
*
* @param m the map whose mappings are to be placed in this map
* @throws NullPointerException if the specified map is null
*/
public HashMap(Map m) {
this.loadFactor = MapUtilConst.DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
/**
* 该函数用于将一个map赋值给新的HashMap
*
*
if (table == null)分支，说明是HashMap的拷贝构造函数来调用的putMapEntries，或者是构造以后还没有放过任何元素，然后再调用putAll。
float ft = ((float)s / loadFactor) + 1.0F
这里的加1是因为，size / loadFactor = capacity，但如果算出来的capacity是小数，却又向下取整，会造成容量不够大，
所以，如果是小数的capacity，那么必须向上取整。
算出来的容量必须小于最大容量MAXIMUM_CAPACITY，否则直接让capacity等于MAXIMUM_CAPACITY。
if (t > threshold)这里的threshold成员实际存放的值是capacity的值。
因为在table还没有初始化时（table还是null），用户给定的capacity会暂存到threshold成员上去（毕竟HashMap没有一个成员叫做capacity，capacity是作为table数组的大小而隐式存在的）。
else if (s > threshold)说明传入map的size都已经大于当前map的threshold了，即当前map肯定是装不下两个map的并集的，所以这里必须要执行resize操作。
最后循环里的putVal可能也会触发resize操作
*
*
* 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 m, boolean evict) {
int s = m.size();
if (s <= 0) {
return;
}
// 判断table是否已经初始化 如果table=null一般就是构造函数来调用的putMapEntries，或者构造后还没放过任何元素
if (table == null) { // pre-size
// 如果未初始化，则计算HashMap的最小需要的容量（即容量刚好不大于扩容阈值）。这里Map的大小s就被当作HashMap的扩容阈值，然后用传入Map的大小除以负载因子就能得到对应的HashMap的容量大小（当前m的大小
// / 负载因子 = HashMap容量）
// 先不考虑容量必须为2的幂，那么下面括号里会算出来一个容量，使得size刚好不大于阈值。但这样会算出小数来，但作为容量就必须向上取整，所以这里要加1。此时ft可以临时看作HashMap容量大小
float ft = ((float) s / loadFactor) + 1.0F;
// 比较最大容量与ft，取小值； 到这里t暂时表示HashMap的容量大小。如果是将ft浮点型赋值给t整形，因为前面加了1.0f,这里也就实现了向上取整
int t = ((ft < (float) MapUtilConst.MAXIMUM_CAPACITY) ? (int) ft : MapUtilConst.MAXIMUM_CAPACITY);
// 只有在算出来的容量t >
// 当前暂存的容量(容量可能会暂放到阈值上的,刚使用构造函数构造出来的HashMap并且没有存入元素时，容量大小就会被暂时存在threshold中)时
// 才会用t计算出新容量，暂时存放到阈值上,在后面触发resize()扩容的时候会对threshold重新计算正确的阈值
if (t > threshold)
threshold = tableSizeFor(t);
}
// 如果当前Map已经初始化,且这个map中的元素个数大于扩容的阀值就得扩容
// 这种情况属于预先扩大容量，再put元素
else if (s > threshold)
resize();
// 遍历map,将map中的key和value都添加到HashMap中
for (Map.Entry e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
/**
* Returns the number of key-value mappings in this map.
*
* @return the number of key-value mappings in this map
*/
public int size() {
return size;
}
/**
* Returns true if this map contains no key-value mappings.
*
* @return true if this map contains no key-value mappings
*/
public boolean isEmpty() {
return size == 0;
}
/**
* Returns the value to which the specified key is mapped, or {@code null} if
* this map contains no mapping for the key.
*
*
* More formally, if this map contains a mapping from a key {@code k} to a value
* {@code v} such that {@code (key==null ? k==null :
* key.equals(k))}, then this method returns {@code v}; otherwise it returns
* {@code null}. (There can be at most one such mapping.)
*
*
* A return value of {@code null} does not necessarily indicate that the
* map contains no mapping for the key; it's also possible that the map
* explicitly maps the key to {@code null}. The {@link #containsKey containsKey}
* operation may be used to distinguish these two cases.
*
* @see #put(Object, Object)
*/
public V get(Object key) {
Node e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* 大致流程：
*
*
1.根据hash值去找到桶。
2.判断桶上的key是否等于传入的的key，如果相等，则直接返回。
3.桶上的key如果不是我们需要的key，则查看next指向的结点。
3.1 如果指向的结点是树结点，调用红黑树的查找方法找到key。
3.2 如果指向的结点是链表，则遍历链表找到key。
1，map不能为空，且hash对应的下标要存在。否则返回null
2，取下标对应的对象，如果该对象的key与入参key一致，则返回该对象
3，否则，获取下一个对象，如果该对象为空，返回null
4，如果当前对象是树结构，则调用getTreeNode，获取是否存在
5，如果不是树结构，循环对象，如果存在对象的key与入参key一致，则返回该对象
6，最终返回要么有值，要么null
*
*
*
*/
final Node getNode(int hash, Object key) {
// 主要用于将哈希表赋值给tab
Node[] tab;
// 主要是通过(哈希表的长度-1) & hash值，计算出数组下标first = tab[n](第 一个节点)
Node first,
// 主要是将当前节点的下个结点赋值给e
e;
// 主要用去哈希表的长度赋值给n
int n;
// 主要用于当前结点的key赋值给k
K k;
// 将哈希表赋值给tab然后判断是否为空
// &&将哈希表的长度赋值给n判断是否大于0
// && 将hash的低十六位(绝大多数情况下length一般都小于2^16)与长度进行运算得到数组下标， tab[下标]赋值给first
if ((tab = table) == null || (n = tab.length) < 0 || (first = tab[(n - 1) & hash]) == null) {
return null;
}
// 拿到第一个结点(first)的hash值和key，跟传入的has值和key作比较，如果相同返回first结点；
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 该索引下面存储多个节点的情况下：将first的下一个结点赋值给e，判断e是否为空
if ((e = first.next) == null) {
return null;
}
// 判断first是否是TreeNode的对象
if (first instanceof TreeNode)
// 如果是，调用在红黑树中的查找方法
return ((TreeNode) first).getTreeNode(hash, key);
// 以链表的方式存储，遍历该节点下面的所有结点
do {
// 判断当前结点(e)的hash值和key，跟传入的has值和key作比较，如果相同返回first结点；(与判断first的结点相同)
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while (null != (e = e.next)); // 获取e节点的下一个是否为空
return null;
}
/**
* Returns true if this map contains a mapping for the specified key.
*
* @param key The key whose presence in this map is to be tested
* @return true if this map contains a mapping for the specified key.
*/
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
/**
* 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 key, or null if
* there was no mapping for key. (A null return can
* also indicate that the map previously associated null with
* key.)
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods.
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent 如果为true，则不更改现有值
* @param evict 如果为false，则表处于创建模式.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
// 获取哈希表中的桶数组和桶数组的长度
Node[] tab;
Node p;
int n, i;
/*
* 如果table为空，或者数组当前长度为0，说明没有创建HashMap，要先创建
* 也说明了HashMap在插入第一个元素的时候才初始化，而不是定义出来才开始初始化 延迟初始化逻辑
*/
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 路由算法 （n-1） & hash == hash%n （n必须为2的次方数）
// 如果这个位置为null，则说明其中没有数据，直接放进去
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 这个位置已经有数据了
else {
// e：临时节点
// k：表示临时的一个key
Node e;
K k;
// p在上面的if语句中赋值，代表对应数组下标的元素
// hash值相同并不一定代表值相同，但如果hash值不相同，值一定不相同
// 表示桶位中的元素该元素，和你当前插入的key完全一致，表示后续需要进行替换操作
if (p.hash == hash &&
// 判断基本类型的key值是否相同，直接使用等于判断 || 判断非基本类型的key值是否相同，要使用equals
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// e值为key值相等的这个元素
// key值不相等，且已经发生树化=>红黑树
else if (p instanceof TreeNode)
e = ((TreeNode) p).putTreeVal(this, tab, hash, key, value);
// 不是树，且key不相等，剩下一种情况=>链表
// 链表的头元素和key不一致，则要遍历整个链表，找到key值就替换，不然就在链表末尾插
else {
for (int binCount = 0;; ++binCount) {
// 遍历整个链表
if ((e = p.next) == null) {
// 一直遍历到空都没有找到key值相等，在表尾插入一个新节点
p.next = newNode(hash, key, value, null);
// MapUtilConst.TREEIFY_THRESHOLD为树化阈值，默认为8
// 因为binCount从0开始，所以当binCount为7的时候，已经有八个节点了，binCount在for循环结束的时候才自增，因此要和树化阈值-1作比较
// 当大于等于阈值的时候，链表树化
if (binCount >= MapUtilConst.TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
// 此时e中存储的为null
break;
}
// 判断key值是否相同，逻辑与上面一样
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;
// 此时跳出e中存储的是key相同的那个地址
p = e;
}
}
// 只有替换操作会进入整个if，插入操作中e的值为null
if (e != null) { // existing mapping for key
// 将原来对应的value值存起来
V oldValue = e.value;
// onlyIfAbsent为false时 或者 原来key对应的value为空值的时候，e.value被赋值为新的value
// 即如果onlyIfAbsent传入的值为true且oldvalue不为空，不执行此if操作，value没有被插入，没有发生替换操作
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
// 返回值为oldvalue，即被覆盖的value值
return oldValue;
}
}
// modCount表示散列表结构被修改次数，替换操作不会走到这里。
++modCount;
// size是散列表中元素的个数，如果大于扩容阈值，会触发扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
/**
* Initializes or doubles table size. If null, allocates in accord with initial
* capacity target held in field threshold. 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[] resize() {
// 当前所有元素所在的数组，称为老的元素数组
Node[] oldTab = table;
// 老的元素数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 老的扩容阀值设置
int oldThr = threshold;
// 新数组的容量，新数组的扩容阀值都初始化为0
int newCap, newThr = 0;
// 如果老数组长度大于0，说明已经存在元素
if (oldCap > 0) {
// 如果数组元素个数大于等于限定的最大容量（2的30次方）
if (oldCap >= MapUtilConst.MAXIMUM_CAPACITY) {
// 扩容阀值设置为int最大值（2的31次方 -1 ），因为oldCap再乘2就溢出了。
threshold = Integer.MAX_VALUE;
// 返回老的元素数组
return oldTab;
}
/*
* 如果数组元素个数在正常范围内，那么新的数组容量为老的数组容量的2倍（左移1位相当于乘以2） 如果扩容之后的新容量小于最大容量 并且
* 老的数组容量大于等于默认初始化容量（16），那么新数组的扩容阀值设置为老阀值的2倍。（老的数组容量大于16意味着：
* 要么构造函数指定了一个大于16的初始化容量值，要么已经经历过了至少一次扩容）
*/
else if ((newCap = oldCap << 1) < MapUtilConst.MAXIMUM_CAPACITY
&& oldCap >= MapUtilConst.DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// PS2
// 运行到这个else if 说明老数组没有任何元素
// 如果老数组的扩容阀值大于0，那么设置新数组的容量为该阀值
// 这一步也就意味着构造该map的时候，指定了初始化容量。
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 能运行到这里的话，说明是调用无参构造函数创建的该map，并且第一次添加元素
// 设置新数组容量 为 16
newCap = MapUtilConst.DEFAULT_INITIAL_CAPACITY;
// 设置新数组扩容阀值为 16*0.75 = 12。0.75为负载因子（当元素个数达到容量了4分之3，那么扩容）
newThr = (int) (MapUtilConst.DEFAULT_LOAD_FACTOR * MapUtilConst.DEFAULT_INITIAL_CAPACITY);
}
// 如果扩容阀值为0 （PS2的情况）
if (newThr == 0) {
float ft = (float) newCap * loadFactor;
newThr = (newCap < MapUtilConst.MAXIMUM_CAPACITY && ft < (float) MapUtilConst.MAXIMUM_CAPACITY ? (int) ft
: Integer.MAX_VALUE);
}
// 设置map的扩容阀值为 新的阀值
threshold = newThr;
@SuppressWarnings({ "rawtypes", "unchecked" })
// 创建新的数组（对于第一次添加元素，那么这个数组就是第一个数组；对于存在oldTab的时候，那么这个数组就是要需要扩容到的新数组）
Node[] newTab = (Node[]) new Node[newCap];
// 将该map的table属性指向到该新数组
table = newTab;
// 如果老数组不为空，说明是扩容操作，那么涉及到元素的转移操作
if (oldTab != null) {
// 遍历老数组
for (int j = 0; j < oldCap; ++j) {
Node e;
// 如果当前位置元素不为空，那么需要转移该元素到新数组
if ((e = oldTab[j]) != null) {
// 释放掉老数组对于要转移走的元素的引用（主要为了使得数组可被回收）
oldTab[j] = null;
// 如果元素没有有下一个节点，说明该元素不存在hash冲突
if (e.next == null)
// PS3
// 把元素存储到新的数组中，存储到数组的哪个位置需要根据hash值和数组长度来进行取模
// 【hash值 % 数组长度】 = 【 hash值 & （数组长度-1）】
// 这种与运算求模的方式要求 数组长度必须是2的N次方，但是可以通过构造函数随意指定初始化容量呀，
// 如果指定了17,15这种，岂不是出问题了就？没关系，最终会通过tableSizeFor方法将用户指定的转化为大于其并且最相近的2的N次方。
// 15 -> 16、17-> 32
newTab[e.hash & (newCap - 1)] = e;
// 如果该元素有下一个节点，那么说明该位置上存在一个链表了（hash相同的多个元素以链表的方式存储到了老数组的这个位置上了）
// 例如：数组长度为16，那么hash值为1（1%16=1）的和hash值为17（17%16=1）的两个元素都是会存储在数组的第2个位置上（对应数组下标为1），当数组扩容为32（1%32=1）时，hash值为1的还应该存储在新数组的第二个位置上，但是hash值为17（17%32=17）的就应该存储在新数组的第18个位置上了。
// 所以，数组扩容后，所有元素都需要重新计算在新数组中的位置。
// 如果该节点为TreeNode类型
else if (e instanceof TreeNode)
((TreeNode) e).split(this, newTab, j, oldCap);
else { // preserve order
// 按命名来翻译的话，应该叫低位首尾节点
Node loHead = null, loTail = null;
// 按命名来翻译的话，应该叫高位首尾节点
Node hiHead = null, hiTail = null;
// 以上的低位指的是新数组的 0 到 oldCap-1 、高位指定的是oldCap 到 newCap - 1
Node next;
// 遍历链表
do {
next = e.next;
// 这一步判断好狠，拿元素的hash值 和 老数组的长度 做与运算
// PS3里曾说到，数组的长度一定是2的N次方（例如16），如果hash值和该长度做与运算，结果为0，就说明该hash值小于数组长度（例如hash值为7），
// 那么该hash值再和新数组的长度取摸的话mod值也不会放生变化，所以该元素的在新数组的位置和在老数组的位置是相同的，所以该元素可以放置在低位链表中。
if ((e.hash & oldCap) == 0) {
// PS4
// 如果没有尾，说明链表为空
if (loTail == null)
// 链表为空时，头节点指向该元素
loHead = e;
else
// 如果有尾，那么链表不为空，把该元素挂到链表的最后。
loTail.next = e;
// 把尾节点设置为当前元素
loTail = e;
}
// 如果与运算结果不为0，说明hash值大于老数组长度（例如hash值为17）
// 此时该元素应该放置到新数组的高位位置上
// 例：老数组长度16，那么新数组长度为32，hash为17的应该放置在数组的第17个位置上，也就是下标为16，那么下标为16已经属于高位了，低位是[0-15]，高位是[16-31]
else {
// 以下逻辑同PS4
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;
// 例：hash为 17 在老数组放置在0下标，在新数组放置在16下标； hash为 18 在老数组放置在1下标，在新数组放置在17下标；
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
/**
*
1，如果table数组为空，或者大小未超过64，则重置table大小
2，如果table大小超过64，把当前链表转换成红黑树
2.1，循环链表，把每一个对象转换成红黑树，并绑定上下级关系
2.2，重置红黑树相关信息
*
*/
final void treeifyBin(Node[] tab, int hash) {
int n, index;
Node e;
// 1，如果table数组为空，或者大小未超过64，则重置table大小
if (tab == null || (n = tab.length) < MapUtilConst.MIN_TREEIFY_CAPACITY)
resize();
// 2，如果table大小超过64，把当前链表转换成红黑树
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode hd = null, tl = null;
do {
// 2.1，循环链表，把每一个对象转换成红黑树，并绑定上下级关系
TreeNode 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);
}
}
/**
* Copies all of the mappings from the specified map to this map. These mappings
* will replace any mappings that this map had for any of the keys currently in
* the specified map.
*
* @param m mappings to be stored in this map
* @throws NullPointerException if the specified map is null
*/
public void putAll(Map m) {
putMapEntries(m, true);
}
/**
* Removes the mapping for the specified key from this map if present.
*
* @param key key whose mapping is to be removed from the map
* @return the previous value associated with key, or null if
* there was no mapping for key. (A null return can
* also indicate that the map previously associated null with
* key.)
*/
public V remove(Object key) {
Node e;
return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value;
}
/**
* Implements Map.remove and related methods.
*
* @param hash hash for key
* @param key the key
* @param value the value to match if matchValue, else ignored
* @param matchValue if true only remove if value is equal
* @param movable if false do not move other nodes while removing
* @return the node, or null if none
*/
final Node removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) {
// tab：当前map
// 的数组，p：hash对应的数组索引index位置上的节点/遍历链表时表示当前遍历到的节点的前一个节点，n：数组长度，index：hash对应的数组索引
// 这几个值在hashMap的源码中很常见
Node[] tab;
Node p;
int n, index;
// 定位到哈希桶中位置
// 前提判断 数组不为空，并且长度大于0 并且
// hash对应的数组索引位置上的节点p也不为null
if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) {
// node：被移除的节点，e：当前头节点的下一个节点/遍历链表时表示当前遍历到的节点，
// k：e节点的key，v：被移除节点node 的value
Node node = null, e;
K k;
V v;
// 直接检索到-挺幸运
// 如果第一个节点p就是目标节点，则将node指向第一个节点p
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
node = p;
// 第一个节点不是，那就看看第一个节点还有没有下一个元素。
// 如果有第二个节点
else if ((e = p.next) != null) {
// 如果刚刚第一个节点是红黑树
if (p instanceof TreeNode)
// 调用红黑树的查询节点的方法，getTreeNode()
node = ((TreeNode) p).getTreeNode(hash, key);
// 第一个节点不是红黑树，并且还有第二个节点，那就说明，这里是链表了
else {
// 那么开始循环链表，从第二个节点开始循环，因为第一个节点已经处理过了
do {
// 判断e节点是不是目标节点，是的话就将node指向e，并且终止循环
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
node = e;
break;
}
// e节点不是目标节点，那就将p节点指向e节点，
// 然后while里面e节点后移，在进入循环后发现e是目标节点了，退出循环，退出后此时p节点还是e节点的前一个节点，
// 也就保证了在整个循环的过程中，p节点始终是e节点的前一个节点。
p = e;
} while ((e = e.next) != null); // e指针后移，并且下一个节点不为null则继续遍历，不为null表示没到链表最后。
}
}
// 找到目标节点了 matchValue为true，则仅在值相等时删除。如果是false，则值不管相不相等，只要key和hash值一致就移除该节点。
if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) {
// 如果目标节点是红黑树
if (node instanceof TreeNode)
// 调用红黑树的删除节点方法
((TreeNode) node).removeTreeNode(this, tab, movable);
// 目标节点是p节点，
// 还记得之前 如果第一个节点p（数组桶中的节点）就是目标节点，则将node指向第一个节点p
else if (node == p)
// 将目标节点的下一个节点作为该索引位置的第一个元素
// 也就是跳过目标节点，指向目标节点的下一位
tab[index] = node.next;
// 这里就是遍历链表找到了目标节点
else
// p节点始终作为node的上一个节点，p.next始终指向目标节点node
// 现在将p.next 指向目标节点node的next，这样跳过了目标节点node，就把node移除掉了
p.next = node.next;
// 记录map结构被修改的次数，主要用于并发编程
++modCount;
// 记录table存储了多少键值对，因为移除了一个，所以此处就减一
--size;
// 该方法在hashMap中是空方法，主要是供LinkedHashMap使用，因为LinkedHashMap重写了该方法
afterNodeRemoval(node);
// 返回被移除的节点
return node;
}
}
// 没找到 返回null
return null;
}
/**
* Removes all of the mappings from this map. The map will be empty after this
* call returns.
*/
public void clear() {
Node[] tab;
modCount++;
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
/**
* Returns true if this map maps one or more keys to the specified
* value.
*
* @param value value whose presence in this map is to be tested
* @return true if this map maps one or more keys to the specified
* value
*/
public boolean containsValue(Object value) {
Node[] tab;
V v;
if ((tab = table) != null && size > 0) {
for (int i = 0; i < tab.length; ++i) {
for (Node e = tab[i]; e != null; e = e.next) {
if ((v = e.value) == value || (value != null && value.equals(v)))
return true;
}
}
}
return false;
}
/**
* Returns a {@link Set} view of the keys contained in this map. The set is
* backed by the map, so changes to the map are reflected in the set, and
* vice-versa. If the map is modified while an iteration over the set is in
* progress (except through the iterator's own remove operation), the
* results of the iteration are undefined. The set supports element removal,
* which removes the corresponding mapping from the map, via the
* Iterator.remove, Set.remove, removeAll,
* retainAll, and clear operations. It does not support the
* add or addAll operations.
*
* @return a set view of the keys contained in this map
*/
public Set keySet() {
Set ks = keySet;
if (ks == null) {
ks = new KeySet();
keySet = ks;
}
return ks;
}
final class KeySet extends AbstractSet {
public final int size() {
return size;
}
public final void clear() {
HashMap.this.clear();
}
public final Iterator iterator() {
return new KeyIterator();
}
public final boolean contains(Object o) {
return containsKey(o);
}
public final boolean remove(Object key) {
return removeNode(hash(key), key, null, false, true) != null;
}
public final Spliterator spliterator() {
return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer action) {
Node[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node e = tab[i]; e != null; e = e.next)
action.accept(e.key);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
/**
* Returns a {@link Collection} view of the values contained in this map. The
* collection is backed by the map, so changes to the map are reflected in the
* collection, and vice-versa. If the map is modified while an iteration over
* the collection is in progress (except through the iterator's own
* remove operation), the results of the iteration are undefined. The
* collection supports element removal, which removes the corresponding mapping
* from the map, via the Iterator.remove, Collection.remove,
* removeAll, retainAll and clear operations. It does
* not support the add or addAll operations.
*
* @return a view of the values contained in this map
*/
public Collection values() {
Collection vs = values;
if (vs == null) {
vs = new Values();
values = vs;
}
return vs;
}
final class Values extends AbstractCollection {
public final int size() {
return size;
}
public final void clear() {
HashMap.this.clear();
}
public final Iterator iterator() {
return new ValueIterator();
}
public final boolean contains(Object o) {
return containsValue(o);
}
public final Spliterator spliterator() {
return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer action) {
Node[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node e = tab[i]; e != null; e = e.next)
action.accept(e.value);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
/**
* Returns a {@link Set} view of the mappings contained in this map. The set is
* backed by the map, so changes to the map are reflected in the set, and
* vice-versa. If the map is modified while an iteration over the set is in
* progress (except through the iterator's own remove operation, or
* through the setValue operation on a map entry returned by the
* iterator) the results of the iteration are undefined. The set supports
* element removal, which removes the corresponding mapping from the map, via
* the Iterator.remove, Set.remove, removeAll,
* retainAll and clear operations. It does not support the
* add or addAll operations.
*
* @return a set view of the mappings contained in this map
*/
public Set> entrySet() {
Set> es;
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}
final class EntrySet extends AbstractSet> {
public final int size() {
return size;
}
public final void clear() {
HashMap.this.clear();
}
public final Iterator> iterator() {
return new EntryIterator();
}
public final boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry) o;
Object key = e.getKey();
Node candidate = getNode(hash(key), key);
return candidate != null && candidate.equals(e);
}
public final boolean remove(Object o) {
if (o instanceof Map.Entry) {
Map.Entry e = (Map.Entry) o;
Object key = e.getKey();
Object value = e.getValue();
return removeNode(hash(key), key, value, true, true) != null;
}
return false;
}
public final Spliterator> spliterator() {
return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer> action) {
Node[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node e = tab[i]; e != null; e = e.next)
action.accept(e);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
// Overrides of JDK8 Map extension methods
@Override
public V getOrDefault(Object key, V defaultValue) {
Node e;
return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}
@Override
public V putIfAbsent(K key, V value) {
return putVal(hash(key), key, value, true, true);
}
@Override
public boolean remove(Object key, Object value) {
return removeNode(hash(key), key, value, true, true) != null;
}
@Override
public boolean replace(K key, V oldValue, V newValue) {
Node e;
V v;
if ((e = getNode(hash(key), key)) != null && ((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
@Override
public V replace(K key, V value) {
Node e;
if ((e = getNode(hash(key), key)) != null) {
V oldValue = e.value;
e.value = value;
afterNodeAccess(e);
return oldValue;
}
return null;
}
/*
* 功能：判断给定的key在hashMap中是否存在，如果key已经存在，则返回key对应的value
* 如果key不存在，则新生成一个节点(hash,key,value,null),value的值是通过 V v =
* mappingFunction.apply(key);获取的，重点是要搞明白mappingFunction.apply(key)这个方法。
*/
@Override
public V computeIfAbsent(K key, Function mappingFunction) {
// 如果自定义的函数为空，抛出空指针异常
if (mappingFunction == null)
throw new NullPointerException();
// 算出给定key的hash值
int hash = hash(key);
// 定义node类型的数组tab,node类型的节点first,定义n,i;
Node[] tab;
Node first;
int n, i;
// 定义二叉树的计数变量
int binCount = 0;
// 定义TreeNode类型的对象t;
TreeNode t = null;
// 定义存放node类型的节点old；
Node old = null;
if (size > threshold || (tab = table) == null || (n = tab.length) == 0)
// 如果hashMap的长度大于扩容临界值或table及tab的长度为空，
// 则走 resize()，该方法可初始化hashMap,也可以对hashMap进行扩容
n = (tab = resize()).length;
if ((first = tab[i = (n - 1) & hash]) != null) {
// 算出key在tab中的存储位置，如果该位置不为空，把该位置存储的节点赋值给first
// 这种情况key已经存在，返回key对应的value值oldValue，key不存在时直接走
// int mc = modCount;及后面的内容，直接新建node，存入key ,value，这种情况下first为null,
if (first instanceof TreeNode)
// 走红黑树分支，找出指定key的赋值给old,t;
old = (t = (TreeNode) first).getTreeNode(hash, key);
else {
// 如果不是红黑树，走到这里就是链表
// 把first节点赋值给e,定义k;
Node e = first;
K k;
do {
// 通过do-while循环，在链表中找出和给定hash值和key相同的节点，找到之后把链表上的节点e赋值给old,然后推出循环;
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
old = e;
break;
}
// 二叉树计算变量+1；
++binCount;
} while ((e = e.next) != null); // 循环遍历链表上的节点
}
V oldValue;
if (old != null && (oldValue = old.value) != null) {
// 红黑树和链表中如果old节点不为空且old节点的value不为空，返回old的value
// //回调函数；
afterNodeAccess(old);
return oldValue;
}
}
/**
* mappingFunction.apply(key)是理解整个computeIfAbsent方法的关键，apply传入的参数是key
* apply(key)执行后返回什么？这个需看apply函数定义： R apply(T t); 该返回值R是接口Function的第二个参数，
* 到这里我们在看调用函数里面传入的参数： Integer integer1 = map.computeIfAbsent("4", (s)->new
* Integer(6)); 对比computeIfAbsent的方法定义:computeIfAbsent(K key,Function mappingFunction) 可知：key是4，s=key，也是4，Function，V对应new Integer(6)的执行结果，所以V对应的是6， 所以Function --->Function<4,
* 6>---> R apply(T 4),R=6;执行完mappingFunction.apply(key)的值是6，所以v=6;
*/
V v = mappingFunction.apply(key);
if (v == null) {
// 通过自定义函数mappingFunction获取的value为空，直接返回null;
return null;
} else if (old != null) {
// 如果old不为空，把v赋值给old的value
old.value = v;
// 回调函数
afterNodeAccess(old);
return v;
}
// 如果在红黑树节点中找到的t节点不为空
else if (t != null)
// 把当前的map，数组tab,hash，key，v存储到红黑树中
t.putTreeVal(this, tab, hash, key, v);
else {
// 在数组tab中新建节点，存入(hash, key, v, first),此时first为null,因为first = tab[i = (n - 1) &
// hash]) = null
tab[i] = newNode(hash, key, v, first);
// 如果大于二叉树转换的条件，走二叉树分支
if (binCount >= MapUtilConst.TREEIFY_THRESHOLD - 1)
// 把tab转换成二叉树
treeifyBin(tab, hash);
}
// 记录hashMap的修改次数
++modCount;
// hashMap的长度加1
++size;
// 回调函数
afterNodeInsertion(true);
return v;
}
/**
* 作用是根据指定键获取该键对应的值，并使用指定的函数生成一个新值，然后将新值存储回 Map 中。
*/
public V computeIfPresent(K key, BiFunction remappingFunction) {
if (remappingFunction == null)
throw new NullPointerException();
Node e;
V oldValue;
int hash = hash(key);
if ((e = getNode(hash, key)) != null && (oldValue = e.value) != null) {
V v = remappingFunction.apply(key, oldValue);
if (v != null) {
e.value = v;
afterNodeAccess(e);
return v;
} else
removeNode(hash, key, null, false, true);
}
return null;
}
/**
* 如果哈希表中不存在 key 这个键，则用 key 和 remappingFunction 计算得到一个新值，并将这个键值对插入到哈希表中；
* 如果哈希表中已经存在 key 这个键，则通过 remappingFunction 计算出一个新值，并用这个新值更新 key 对应的值。
*/
@Override
public V compute(K key, BiFunction remappingFunction) {
if (remappingFunction == null)
throw new NullPointerException();
int hash = hash(key);
Node[] tab;
Node first;
int n, i;
int binCount = 0;
TreeNode t = null;
Node old = null;
if (size > threshold || (tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((first = tab[i = (n - 1) & hash]) != null) {
if (first instanceof TreeNode)
old = (t = (TreeNode) first).getTreeNode(hash, key);
else {
Node e = first;
K k;
do {
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
old = e;
break;
}
++binCount;
} while ((e = e.next) != null);
}
}
V oldValue = (old == null) ? null : old.value;
V v = remappingFunction.apply(key, oldValue);
if (old != null) {
if (v != null) {
old.value = v;
afterNodeAccess(old);
} else
removeNode(hash, key, null, false, true);
} else if (v != null) {
if (t != null)
t.putTreeVal(this, tab, hash, key, v);
else {
tab[i] = newNode(hash, key, v, first);
if (binCount >= MapUtilConst.TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
}
++modCount;
++size;
afterNodeInsertion(true);
}
return v;
}
@Override
public V merge(K key, V value, BiFunction remappingFunction) {
if (value == null)
throw new NullPointerException();
if (remappingFunction == null)
throw new NullPointerException();
int hash = hash(key);
Node[] tab;
Node first;
int n, i;
int binCount = 0;
TreeNode t = null;
Node old = null;
if (size > threshold || (tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((first = tab[i = (n - 1) & hash]) != null) {
if (first instanceof TreeNode)
old = (t = (TreeNode) first).getTreeNode(hash, key);
else {
Node e = first;
K k;
do {
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
old = e;
break;
}
++binCount;
} while ((e = e.next) != null);
}
}
if (old != null) {
V v;
if (old.value != null)
v = remappingFunction.apply(old.value, value);
else
v = value;
if (v != null) {
old.value = v;
afterNodeAccess(old);
} else
removeNode(hash, key, null, false, true);
return v;
}
if (value != null) {
if (t != null)
t.putTreeVal(this, tab, hash, key, value);
else {
tab[i] = newNode(hash, key, value, first);
if (binCount >= MapUtilConst.TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
}
++modCount;
++size;
afterNodeInsertion(true);
}
return value;
}
@Override
public void forEach(BiConsumer action) {
Node[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node e = tab[i]; e != null; e = e.next)
action.accept(e.key, e.value);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
@Override
public void replaceAll(BiFunction function) {
Node[] tab;
if (function == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node e = tab[i]; e != null; e = e.next) {
e.value = function.apply(e.key, e.value);
}
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
/* ------------------------------------------------------------ */
// Cloning and serialization
/**
* Returns a shallow copy of this HashMap instance: the keys and values
* themselves are not cloned.
*
* @return a shallow copy of this map
*/
@SuppressWarnings("unchecked")
@Override
public Object clone() {
HashMap result;
try {
result = (HashMap) super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
result.reinitialize();
result.putMapEntries(this, false);
return result;
}
// These methods are also used when serializing HashSets
final float loadFactor() {
return loadFactor;
}
final int capacity() {
return (table != null) ? table.length : (threshold > 0) ? threshold : MapUtilConst.DEFAULT_INITIAL_CAPACITY;
}
/**
* Save the state of the HashMap instance to a stream (i.e., serialize
* it).
*
* @serialData The capacity of the HashMap (the length of the bucket
* array) is emitted (int), followed by the size (an int, the
* number of key-value mappings), followed by the key (Object) and
* value (Object) for each key-value mapping. The key-value mappings
* are emitted in no particular order.
*/
private void writeObject(java.io.ObjectOutputStream s) throws IOException {
int buckets = capacity();
// Write out the threshold, loadfactor, and any hidden stuff
s.defaultWriteObject();
s.writeInt(buckets);
s.writeInt(size);
internalWriteEntries(s);
}
/**
* Reconstitutes this map from a stream (that is, deserializes it).
*
* @param s the stream
* @throws ClassNotFoundException if the class of a serialized object could not
* be found
* @throws IOException if an I/O error occurs
*/
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
// Read in the threshold (ignored), loadfactor, and any hidden stuff
s.defaultReadObject();
reinitialize();
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new InvalidObjectException("Illegal load factor: " + loadFactor);
s.readInt(); // Read and ignore number of buckets
int mappings = s.readInt(); // Read number of mappings (size)
if (mappings < 0)
throw new InvalidObjectException("Illegal mappings count: " + mappings);
else if (mappings > 0) { // (if zero, use defaults)
// Size the table using given load factor only if within
// range of 0.25...4.0
float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
float fc = (float) mappings / lf + 1.0f;
int cap = ((fc < MapUtilConst.DEFAULT_INITIAL_CAPACITY) ? MapUtilConst.DEFAULT_INITIAL_CAPACITY
: (fc >= MapUtilConst.MAXIMUM_CAPACITY) ? MapUtilConst.MAXIMUM_CAPACITY : tableSizeFor((int) fc));
float ft = (float) cap * lf;
threshold = ((cap < MapUtilConst.MAXIMUM_CAPACITY && ft < MapUtilConst.MAXIMUM_CAPACITY) ? (int) ft
: Integer.MAX_VALUE);
// Check Map.Entry[].class since it's the nearest public type to
// what we're actually creating.
SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
@SuppressWarnings({ "rawtypes", "unchecked" })
Node[] tab = (Node[]) new Node[cap];
table = tab;
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
}
}
/* ------------------------------------------------------------ */
// iterators
abstract class HashIterator {
Node next; // next entry to return
Node current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
HashIterator() {
expectedModCount = modCount;
Node[] t = table;
current = next = null;
index = 0;
if (t != null && size > 0) { // advance to first entry
do {
} while (index < t.length && (next = t[index++]) == null);
}
}
public final boolean hasNext() {
return next != null;
}
final Node nextNode() {
Node[] t;
Node e = next;
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
if ((next = (current = e).next) == null && (t = table) != null) {
do {
} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
public final void remove() {
Node p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;
}
}
final class KeyIterator extends HashIterator implements Iterator {
public final K next() {
return nextNode().key;
}
}
final class ValueIterator extends HashIterator implements Iterator {
public final V next() {
return nextNode().value;
}
}
final class EntryIterator extends HashIterator implements Iterator> {
public final Map.Entry next() {
return nextNode();
}
}
/* ------------------------------------------------------------ */
// spliterators
/* ------------------------------------------------------------ */
// LinkedHashMap support
/*
* The following package-protected methods are designed to be overridden by
* LinkedHashMap, but not by any other subclass. Nearly all other internal
* methods are also package-protected but are declared final, so can be used by
* LinkedHashMap, view classes, and HashSet.
*/
// Create a regular (non-tree) node
Node newNode(int hash, K key, V value, Node next) {
return new Node<>(hash, key, value, next);
}
// For conversion from TreeNodes to plain nodes
Node replacementNode(Node p, Node next) {
return new Node<>(p.hash, p.key, p.value, next);
}
// Create a tree bin node
TreeNode newTreeNode(int hash, K key, V value, Node next) {
return new TreeNode<>(hash, key, value, next);
}
// For treeifyBin
TreeNode replacementTreeNode(Node p, Node next) {
return new TreeNode<>(p.hash, p.key, p.value, next);
}
/**
* Reset to initial default state. Called by clone and readObject.
*/
void reinitialize() {
table = null;
entrySet = null;
keySet = null;
values = null;
modCount = 0;
threshold = 0;
size = 0;
}
// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node p) {
}
void afterNodeInsertion(boolean evict) {
}
void afterNodeRemoval(Node p) {
}
// Called only from writeObject, to ensure compatible ordering.
void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
Node[] tab;
if (size <= 0 || (tab = table) == null) {
return;
}
for (int i = 0; i < tab.length; ++i) {
for (Node e = tab[i]; e != null; e = e.next) {
s.writeObject(e.key);
s.writeObject(e.value);
}
}
}
}
```
# HashMap 介绍
- #### HashMap 是怎样实现的？
- hashmap 是由 数组 + 链表 + 红黑树实现的
- #### hashmap 为什么采用这种方式实现？
- 我们都知道hashmap是根据算得哈希值来确定数据存放的位置，但是我们也知道哈希值会一样，也就是哈希碰撞这种情况。
为了让哈希值一样的数据能有地方存储，于是采用了当发生哈希碰撞时，在原数据位置继续存放的方式，而链表这种数据结构就刚好满足要求
- java8不是用红黑树来管理hashmap，而是在hash值相同的情况下（且重复数量大于8），用红黑树来管理数据。 红黑树相当于排序数据，可以自动的使用二分法进行定位，性能较高
- #### HashMap在jdk1.8之后引入了红黑树的概念，为什么采用6和8进行红黑树和链表转化？
- **6和8是指：表示若桶中链表元素超过8时，会自动转化成红黑树；若桶中元素小于等于6时，树结构还原成链表形式。**
- 原因：
- 1）红黑树的平均查找长度是log(n)，长度为8，查找长度为log(8)=3，链表的平均查找长度为n/2，当长度为8时，平均查找长度为8/2=4，这才有转换成树的必要；链表长度如果是小于等于6，6/2=3，虽然速度也很快的，但是转化为树结构和生成树的时间并不会太短。
- 2）选择6和8的原因1：
如果是小于等于6，6/2=3，虽然速度也很快的，但是转化为树结构和生成树的时间并不会太短。
- 3）选择6和8的原因2：
中间有个差值7可以防止链表和树之间频繁的转换。假设一下，如果设计成链表个数超过8则链表转换成树结构，链表个数小于8则树结构转换成链表，如果一个HashMap不停的插入、删除元素，链表个数在8左右徘徊，就会频繁的发生树转链表、链表转树，效率会很低。
- #### hashmap 是如何提高散列程度的？
- ```java
// 数组容量2的倍数【resize()方法扩容体现出 】，目的是提高运算速度；增加散列度，降低冲突；减少内存碎片。
//左移一位。故数组容量2的倍数
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1;
```
- ```java
// hashcode的高16位与低16位进行异或，目的是增加散列度，降低冲突。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
```
- #### hashmap 提高散列程度为何这样实现？
- [https://blog.csdn.net/liuxingrong666/article/details/103640412](https://blog.csdn.net/liuxingrong666/article/details/103640412 "文章链接")
- #### HashMap 如何扩容？
- 当散列表中元素的个数，如果大于扩容阈值，会触发扩容
- 判断元素个数是不是超过最大值，若超过则置为最大值
- 扩容的容量为原来的2倍
- 若原来有元素，则把原来的元素拷贝到新数组中
-
# NIO
# 缓冲区
1. #### HeapBuffer 与 DirectByteBuffer的区别是啥？
- [](http://wiki.shopqorg.com/uploads/images/gallery/2023-09/Yi4image.png)
# java 字节码
介绍 字节码
# ALOAD
#### **`ALOAD 1`** 是 Java 字节码中的一种指令。`ALOAD` 是 "Load Argument" 的缩写，它用于从方法调用栈的局部变量表中加载一个参数。数字 `1` 表示你要加载的参数的索引。
**在 Java 方法调用中，参数是按照它们的类型和出现的顺序进行排列的。第一个参数是索引 `0`，第二个参数是索引 `1`，以此类推。因此，`ALOAD 1` 会从方法调用栈的局部变量表中加载第二个参数。**
**这个指令通常在调用需要参数的方法时使用，比如在 Java 中调用一个带有参数的方法**
```java
public class Example {
public void myMethod(int a, int b) {
// Do something with a and b
}
public static void main(String[] args) {
Example example = new Example();
example.myMethod(1, 2); // ALOAD 1 would load the second argument (2) into a local variable
}
}
```
**在这个例子中，`ALOAD 1` 会加载第二个参数（在这个例子中是 `2`）到局部变量表中。然后，这个值就可以在方法内部使用了**
# 基本返回类型
##### Z 表示 Boolean 类型。
# GETSTATIC
##### **GETSTATIC 是 Java 字节码指令集中的一个指令，用于获取一个静态字段的值。它通常用于在 Java 字节码中访问静态变量。**
**当执行 GETSTATIC 指令时，Java 虚拟机将获取指定字段的值，并将其推入操作数栈中。这样，您就可以在字节码中使用其他指令对该值进行操作或返回给调用者。**
# NESTMEMBER指令
##### **NESTMEMBER是Java字节码中的一个指令，它用于表示一个类成员嵌套在另一个类中。这个指令通常用于表示一个内部类或嵌套类成员。**
##### 在Java字节码中，NESTMEMBER指令用于指示一个类成员是另一个类的成员。这个指令通常用于表示一个内部类或嵌套类成员。当一个类包含另一个类的成员时，可以使用NESTMEMBER指令来表示这个关系。
##### 例如，假设有一个外部类A和一个内部类B，B是A的一个成员。在字节码中，可以使用NESTMEMBER指令来表示这个关系。具体来说，在A的字节码中，可以使用NESTMEMBER指令来指示B是A的一个成员。
##### 这个指令通常在Java字节码编辑器或反编译器中使用，以帮助开发者或分析者更好地理解Java类的结构。
# INNERCLASS
- ##### **INNERCLASS 说明**
##### INNERCLASS是Java字节码中的一个指令，它用于表示一个内部类或嵌套类。这个指令通常用于在字节码中标记一个类为内部类或嵌套类。
##### 在Java中，内部类是一种特殊的类，它被定义在另一个类的内部。内部类可以访问外部类的成员，包括私有成员。这种特性使得内部类在实现一些特定功能时非常有用，例如访问控制、封装和代码重用等。
##### 在Java字节码中，使用INNERCLASS指令来表示一个类是内部类或嵌套类。这个指令通常用于在字节码中标记内部类的信息，以便在运行时被JVM（Java虚拟机）正确地加载和解析。
##### 例如，假设有一个外部类A和一个内部类B，B被定义在A的内部。在字节码中，可以使用INNERCLASS指令来表示这个关系。具体来说，在A的字节码中，可以使用INNERCLASS指令来指示B是A的一个内部类。
##### 这个指令通常在Java字节码编辑器或反编译器中使用，以帮助开发者或分析者更好地理解Java类的结构。
#####
- ##### **NESTMEMBER 和 INNERCLASS的区别**
- NESTMEMBER和INNERCLASS都是Java字节码中的指令，用于表示内部类或嵌套类的关系。但是，它们之间有一些区别。NESTMEMBER是Java字节码中的一种指令，用于表示一个类成员嵌套在另一个类中。它通常用于表示一个内部类或嵌套类成员，指示这个类成员是另一个类的成员。NESTMEMBER指令通常用于在字节码中标记内部类或嵌套类的信息，以便在运行时被JVM（Java虚拟机）正确地加载和解析。INNERCLASS是Java字节码中的另一种指令，用于表示一个内部类或嵌套类。它通常用于在字节码中标记一个类为内部类或嵌套类。INNERCLASS指令通常用于在字节码中提供内部类的信息，以便在运行时被JVM（Java虚拟机）正确地加载和解析。 ##### **因此，NESTMEMBER和INNERCLASS的区别在于它们的使用方式和目的。NESTMEMBER指令用于表示一个类成员嵌套在另一个类中，而INNERCLASS指令用于表示一个类是内部类或嵌套类。**
# ASTORE
**ASTORE是Java字节码中的一种指令，用于将对象引用存储到局部变量表中。这个指令通常用于在方法中创建对象并将其存储在局部变量中，以便在方法的其他部分中使用该对象。**
ASTORE指令的语法格式为：
```java
astore
```
其中，<variable\_name>是一个变量名，用于指定要存储对象的局部变量的名称。当执行ASTORE指令时，JVM（Java虚拟机）将在局部变量表中创建一个新条目，并将对象的引用存储在该条目中。
需要注意的是，ASTORE指令只能用于存储对象引用，不能用于存储基本类型的数据（如int、char等）。如果需要存储基本类型的数据，应该使用ISTORE或FSTORE指令。
ASTORE指令通常在Java编译器自动生成的字节码中使用，用于支持Java程序中的对象操作。开发者通常不需要手动编写ASTORE指令，因为Java编译器会自动将变量声明和赋值转换为适当的字节码指令。
也可这样：
**ASTORE 1是Java字节码中的一种指令，用于将对象引用存储到操作数栈顶的局部变量表中。这个指令通常用于在方法中创建一个对象并将其引用存储在局部变量表中，以便在方法的其他部分中使用该对象。**
ASTORE指令的语法格式为：
```
astore
```
其中，<variable\_index>是一个整数，表示局部变量表的索引。JVM（Java虚拟机）将在局部变量表中创建一个新条目，并将对象的引用存储在该条目中。
需要注意的是，ASTORE指令只能用于存储对象引用，不能用于存储基本类型的数据（如int、char等）。如果需要存储基本类型的数据，应该使用ISTORE或FSTORE指令。
ASTORE指令通常在Java编译器自动生成的字节码中使用，用于支持Java程序中的对象操作。开发者通常不需要手动编写ASTORE指令，因为Java编译器会自动将变量声明和赋值转换为适当的字节码指令。
# LOCALVARIABLE MAXSTACK 介绍
1. **`LOCALVARIABLE context Lcom/sun/tools/javac/util/Context; L0 L4 0`**
##### 这行代码表示在方法的栈帧中声明了一个名为`context`的局部变量，其类型为`com.sun.tools.javac.util.Context`。
##### `L0`表示这个局部变量在栈帧中的起始位置是0，
##### `L4`表示这个局部变量的长度是4（通常表示它占用了4个字节），
##### 最后的`0`表示这个局部变量没有在方法参数中声明。
2\. **`LOCALVARIABLE instance Lcom/sun/tools/javac/code/Types; L1 L4 1`**
##### 这行代码和上一行类似，声明了一个名为`instance`的局部变量，其类型为`com.sun.tools.javac.code.Types`。`L1`表示这个局部变量在栈帧中的起始位置是1，长度是4，最后的`1`表示这个局部变量是方法的一个参数。
3\. **`MAXSTACK = 3`**
##### 这行代码指定了此方法中使用的最大栈深度为3。这意味着在任何时间点，方法的执行堆栈最多可以有3个元素。
4\. **`MAXLOCALS = 2`**
##### 这行代码指定了此方法中使用的最大局部变量数量为2。这意味着方法中最多可以有2个不同的局部变量同时存在。
# hotspot
Java 虚拟机
# hotspot 源码目录介绍
```text
├─agent Serviceability Agent的客户端实现
├─make 用来build出HotSpot的各种配置文件
├─src HotSpot VM的源代码
│ ├─cpu CPU相关代码（汇编器、模板解释器、ad文件、部分runtime函数在这里实现）
│ ├─os 操作系相关代码
│ ├─os_cpu 操作系统+CPU的组合相关的代码
│ └─share 平台无关的共通代码
│ ├─tools 工具
│ │ ├─hsdis 反汇编插件
│ │ ├─IdealGraphVisualizer 将server编译器的中间代码可视化的工具
│ │ ├─launcher 启动程序“java”
│ │ ├─LogCompilation 将-XX:+LogCompilation输出的日志（hotspot.log）整理成更容易阅读的格式的工具
│ │ └─ProjectCreator 生成Visual Studio的project文件的工具
│ └─vm HotSpot VM的核心代码
│ ├─adlc 平台描述文件（上面的cpu或os_cpu里的*.ad文件）的编译器
│ ├─asm 汇编器接口
│ ├─c1 client编译器（又称“C1”）
│ ├─ci 动态编译器的公共服务/从动态编译器到VM的接口
│ ├─classfile 类文件的处理（包括类加载和系统符号表等）
│ ├─code 动态生成的代码的管理
│ ├─compiler 从VM调用动态编译器的接口
│ ├─gc_implementation GC的实现
│ │ ├─concurrentMarkSweep Concurrent Mark Sweep GC的实现
│ │ ├─g1 Garbage-First GC的实现（不使用老的分代式GC框架）
│ │ ├─parallelScavenge ParallelScavenge GC的实现（server VM默认，不使用老的分代式GC框架）
│ │ ├─parNew ParNew GC的实现
│ │ └─shared GC的共通实现
│ ├─gc_interface GC的接口
│ ├─interpreter 解释器，包括“模板解释器”（官方版在用）和“C++解释器”（官方版不在用）
│ ├─libadt 一些抽象数据结构
│ ├─memory 内存管理相关（老的分代式GC框架也在这里）
│ ├─oops HotSpot VM的对象系统的实现
│ ├─opto server编译器（又称“C2”或“Opto”）
│ ├─prims HotSpot VM的对外接口，包括部分标准库的native部分和JVMTI实现
│ ├─runtime 运行时支持库（包括线程管理、编译器调度、锁、反射等）
│ ├─services 主要是用来支持JMX之类的管理功能的接口
│ ├─shark 基于LLVM的JIT编译器（官方版里没有使用）
│ └─utilities 一些基本的工具类
└─test 单元测试
```
# jvm
jvm 概要
# jvm 执行Java 文件流程
**问题:**
- **虚拟机如何执行Java代码的？**
- **通过把字节码转换成汇编代码保存到内存，修改指令代码执行？**
-
```c++
int JavaMain(void* _args)
{
JavaMainArgs *args = (JavaMainArgs *)_args;
int argc = args->argc;
char **argv = args->argv;
int mode = args->mode;
char *what = args->what;
InvocationFunctions ifn = args->ifn;
JavaVM *vm = 0;
JNIEnv *env = 0;
jclass mainClass = NULL;
jclass appClass = NULL; // 正在启动的实际应用程序类
jmethodID mainID;
jobjectArray mainArgs;
int ret = 0;
jlong start = 0, end = 0;
RegisterThread();
/* 初始化虚拟机 */
start = CurrentTimeMicros();
if (!InitializeJVM(&vm, &env, &ifn)) {
JLI_ReportErrorMessage(JVM_ERROR1);
exit(1);
}
if (showSettings != NULL) {
ShowSettings(env, showSettings);
CHECK_EXCEPTION_LEAVE(1);
}
// 显示已解析的模块并继续
if (showResolvedModules) {
ShowResolvedModules(env);
CHECK_EXCEPTION_LEAVE(1);
}
// 列出可观察模块，然后退出
if (listModules) {
ListModules(env);
CHECK_EXCEPTION_LEAVE(1);
LEAVE();
}
// 描述模块，然后退出
if (describeModule != NULL) {
DescribeModule(env, describeModule);
CHECK_EXCEPTION_LEAVE(1);
LEAVE();
}
if (printVersion || showVersion) {
PrintJavaVersion(env, showVersion);
CHECK_EXCEPTION_LEAVE(0);
if (printVersion) {
LEAVE();
}
}
// 模块已在启动时验证，因此退出
if (validateModules) {
LEAVE();
}
/* 如果用户既没有指定类名也没有指定JAR文件 */
if (printXUsage || printUsage || what == 0 || mode == LM_UNKNOWN) {
PrintUsage(env, printXUsage);
CHECK_EXCEPTION_LEAVE(1);
LEAVE();
}
FreeKnownVMs(); /* 上次可能的打印使用之后 */
// JLI是跟踪启动器?
if (JLI_IsTraceLauncher()) {
end = CurrentTimeMicros();
JLI_TraceLauncher("%ld micro seconds to InitializeJVM\n", (long)(end-start));
}
/* 在此阶段，argc/argv具有应用程序的参数 */
if (JLI_IsTraceLauncher()){
int i;
printf("%s is '%s'\n", launchModeNames[mode], what);
printf("App's argc is %d\n", argc);
for (i=0; i < argc; i++) {
printf(" argv[%2d] = '%s'\n", i, argv[i]);
}
}
ret = 1;
/*
* 获取应用程序的主类。它还检查主方法是否存在。
*
* See bugid 5030265.
* 已经从清单中解析了Main类名，但没有正确解析以支持UTF-8。
* 因此，这里的代码会忽略先前提取的值，并使用预先存在的代码重新提取该值。
* 这可能是发布周期结束的权宜之计。然而，人们也发现，在Windows的一些变体上，通过环境传递一些字符集会有“奇怪”的行为。
* 因此，可能永远不应该增强启动器本地的清单解析代码。
*
* 因此，未来的工作应该:
* 1) 更正本地解析代码，并验证Main Class属性是否在所有环境中正确传递,
* 2) 删除通过环境维护main类的遗留问题（并删除这些注释）。
* 此方法还正确地处理启动现有的Java FX应用程序，这些应用程序可能有Main Class清单条目，也可能没有。
*/
mainClass = LoadMainClass(env, mode, what);
CHECK_EXCEPTION_NULL_LEAVE(mainClass);
/*
* 在一些情况下。，
* 一个没有main方法的JavaFX应用程序，main Class将不是应用程序自己的主类，而是一个辅助类。
* 为了在UI中保持一致，我们需要跟踪和报告应用程序主类。
*/
appClass = GetApplicationClass(env);
NULL_CHECK_RETURN_VALUE(appClass, -1);
/* 生成特定于平台的参数数组 */
mainArgs = CreateApplicationArgs(env, argv, argc);
CHECK_EXCEPTION_NULL_LEAVE(mainArgs);
if (dryRun) {
ret = 0;
LEAVE();
}
/*
* PostJVMInit 将类名用作GUI用途的应用程序名称,
* 例如，在OSX上，这将在SWT和JavaFX的菜单栏中设置应用程序名称。
* 因此，我们将在这里传递实际的应用程序类，而不是主类，因为它可能是一个启动器或帮助程序类而不是应用程序类。
*/
PostJVMInit(env, appClass, vm);
CHECK_EXCEPTION_LEAVE(1);
/**
* Load Main Class不仅加载主类，还将确保主方法的签名是正确的，因此不需要进一步检查。
* 这里调用main方法，以便在应用程序堆栈跟踪中不存在无关的java堆栈。
*/
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
"([Ljava/lang/String;)V");
CHECK_EXCEPTION_NULL_LEAVE(mainID);
/* Invoke主方法. 调用java main 函数 */
(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);
/*
* 如果main抛出异常，启动器的退出代码（在没有调用System.exit的情况下）将为非零。
*/
ret = (*env)->ExceptionOccurred(env) == NULL ? 0 : 1;
LEAVE();
}
```
# generate_normal_entry
1. 确定代码生成标志
2. 获取入口点地址
3. 常量函数地址
4. 访问标志地址
5. 参数数量
6. 本地变量数量
7. 获取参数shu'l
# jvm 运行图
[](http://wiki.shopqorg.com/uploads/images/gallery/2023-11/jvm-run.png)
[](http://wiki.shopqorg.com/uploads/images/gallery/2023-11/jvm.png)
# 影子页面
**影子页面（Shadow Page）是指在虚拟化技术中，为了实现虚拟机对物理机的模拟，而在虚拟机中创建的与物理机页面相对应的页面。**影子页面通常由虚拟机监控器（Hypervisor）根据物理机的页面表而生成，用于保存物理机的页面数据，以便在虚拟机中访问物理机时进行地址转换和页面映射。
在虚拟机运行时，操作系统会将虚拟地址转换为物理地址，以访问物理机的内存和硬件资源。这个转换过程中，影子页面起到了关键的作用。当虚拟机尝试访问一个虚拟地址时，会触发一个页面异常，这时虚拟机监控器会检查影子页面表，以确定该虚拟地址所对应的物理地址。如果影子页面表中存在该物理地址的影子页面，那么虚拟机就可以继续执行；否则，虚拟机监控器会将该影子页面加载到物理内存中，并将物理地址写入影子页面表，以供虚拟机继续访问。
影子页面的使用可以保证虚拟机的隔离和安全性，因为每个虚拟机都有自己的影子页面表，并且影子页面表对虚拟机是透明的。这样就可以防止虚拟机直接访问物理内存和其他资源，从而保护宿主机和虚拟机的安全。
# 预留/黄色区域
**当我们重新进入Java时，我们需要重新启用在虚拟机中可能已经被禁用的预留/黄色区域**。
\*
\* 在虚拟机中，**预留区域（Reserved Zone）的作用主要是为了防止栈溢出的攻击**。这个区域是在Java堆栈中设置的一个安全地带，用于保护程序的安全运行。
\* 如果线程请求的堆栈大小超过了当前堆栈的容量，Java虚拟机会抛出StackOverflowError异常。
\* 在这种情况下，如果存在预留区域，Java虚拟机就会在这个区域内分配新的堆栈，以容纳更多线程。
\* 这样，即使在堆栈溢出的情况下，程序也能继续运行，而不会出现异常或崩溃。
\* 需要注意的是，预留区域的大小是动态变化的，它会根据线程请求的堆栈大小进行调整。
\* 如果请求的堆栈大小超出了当前预留区域的容量，Java虚拟机会尝试扩展预留区域的大小，以满足线程的需求。
\* 此外，预留区域还可以用于实现一些特殊的功能，比如实现线程的本地存储（Thread-local storage），
\* 为每个线程分配独立的内存空间，以存储线程的本地变量和数据。这
\* 样可以避免不同线程之间的数据干扰和冲突，保证程序的安全性和稳定性。
\*
\* **黄色区域指的是线程私有的三个模块**，
\* 即虚拟机栈、
\* 本地方法栈
\* 程序计数器。
\* 这些区域是隔离的，每个线程都有自己的私有实例，不允许其他线程访问。
\* 这种隔离有助于保护线程数据的安全性和独立性。
\* 虚拟机规范将这些区域划分为黄色，是为了强调它们是线程私有的，与共享的绿色区域相区别。
\* **绿色区域是线程共享的数据区域，可以被多个线程共同访问和修改。**
\* 这种划分使得虚拟机能够更好地管理线程之间的协作和并发操作，从而提高程序的性能和安全性。
\* 总之，黄色区域是虚拟机中线程私有的内存区域，用于存储线程的私有数据和执行线程的操作。
\* 这种隔离有助于保护线程数据的安全性和独立性。
# jvm 常量池类型说明
[](http://wiki.shopqorg.com/uploads/images/gallery/2023-11/K2Mimage.png)
# 新页面
# jspringboot 时间配置
```java
package com.conson.tech.frame.core.config;
import cn.hutool.core.date.DatePattern;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.YearMonthDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.YearMonthSerializer;
import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.YearMonth;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
import java.util.TimeZone;
/**
* admin
* Created by admin on 2020/2/26.
*/
@Configuration
@ConditionalOnClass(ObjectMapper.class)
@AutoConfigureBefore(JacksonAutoConfiguration.class)
public class JacksonConfiguration {
@Bean
@ConditionalOnMissingBean
public Jackson2ObjectMapperBuilderCustomizer customizer() {
SimpleModule simpleModule = new SimpleModule();
//Long 转String类型，解决前端丢失精度
simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
simpleModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)));
simpleModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
simpleModule.addDeserializer(YearMonth.class, new YearMonthDeserializer(DateTimeFormatter.ofPattern("yyyy-MM")));
simpleModule.addSerializer(YearMonth.class, new YearMonthSerializer(DateTimeFormatter.ofPattern("yyyy-MM")));
simpleModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_TIME_PATTERN)));
simpleModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)));
simpleModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
simpleModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_TIME_PATTERN)));
return builder -> {
builder.locale(Locale.CHINA);
builder.timeZone(TimeZone.getTimeZone(ZoneId.systemDefault()));
builder.simpleDateFormat(DatePattern.NORM_DATETIME_PATTERN);
// builder.serializationInclusion(JsonInclude.Include.NON_NULL);
builder.modules(simpleModule,new ParameterNamesModule(),new Jdk8Module());
};
}
}
```
# jdb 命令
# jdb 使用
java jdb断点
Java JDB（Java Debugger）是Java开发工具包的一部分，它是一个命令行调试器，允许开发者在程序执行期间监视和修改程序状态。
在Java程序中设置断点，你可以使用JDB的`stop at`或`stop in`命令。以下是如何使用这些命令设置断点的例子：
1. 启动JDB，并指定要调试的类：
```shell
1、jdb YourClassName
# 分包使用
2、jdb -classpath ./lib
3、执行 run -jar jar表名
```
2. 在JDB提示符下，使用`stop at`命令设置断点，例如在某个特定的行号上：
```shell
stop at YourClassName.java:42
```
或者在某个特定的方法上：
```shell
stop in com.zhihuiqd.jhgl.logic.InvoiceLogic.delete
```
这会在执行到指定行或方法时暂停程序。
3. 一旦设置了断点，使用`cont`命令继续程序的执行：
```shell
cont
```
4. 当程序在断点处暂停时，你可以使用其他JDB命令来检查变量值、线程状态等。例如：
```shell
locals
```
显示当前堆栈帧的局部变量。
```shell
step
```
执行下一行代码，并进入任何方法调用内部。
```shell
next
```
执行下一行代码，但不进入任何方法调用内部。
```shell
eval expression
```
计算表达式的值。
5. 当你完成调试后，可以使用`quit`命令退出JDB：
```shell
quit
```
请注意，JDB是一个较旧的调试工具，现代IDE如IntelliJ IDEA和Eclipse通常带有更先进的调试工具，建议在日常开发中使用这些IDE的内置调试功能。
