シリーズ記事ディレクトリ
【Javaの基礎】StringBuffer、StringBuilderクラスのアプリケーションとソースコード解析
【Javaの基礎】配列アプリケーションとソースコードの解析
【Javaの基礎】文字列、メモリアドレスの解析、ソースコード
【JDK8環境でのHashMapクラスのアプリケーションとソースコード解析】最初の空コンストラクターの初期化
[JDK8環境でのHashMapクラスの適用とソースコード解析] 2回目はHashMapの拡張の仕組みを理解するためにソースコードを見てみる [
JDK8環境でのHashMapクラスの適用とソースコード分析] 3回目は容量の実験を変更する
[HashMapクラス] JDK8 環境でのアプリケーションとソースコードの分析] ソースコード分析] 第 4 部 HashMap のハッシュ衝突、HashMap の格納構造、リンク リストが赤と黒のツリーになる
記事ディレクトリ
1. JDK8におけるHashMapのデータ構造
HashMap は配列とリンク リスト (または赤黒ツリー) に基づくデータ構造で、ハッシュ関数を通じてキーを配列の位置にマップし、その位置にキーと値のペアのノードを格納します。
データを挿入する前に、HashMap の put メソッドは、まずハッシュ値 (hash(key)) とキーのインデックスを計算し、その後、対応する位置にノードを挿入または更新する必要があります。ノード数がしきい値 (threshold) を超えた場合は、 、容量の拡張 (resize()) またはツリー化が行われます。
HashMap の get メソッドは主に、キーのハッシュ値とインデックスに従って対応する位置を見つけ、リンクされたリストまたは赤黒ツリーを走査して一致する値を返します。
1.1、ハッシュ
public class HashMap {
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
}
public class Object {
public native int hashCode();
}
public final class System {
/**
* Returns the same hash code for the given object as
* would be returned by the default method hashCode(),
* whether or not the given object's class overrides
* hashCode().
* The hash code for the null reference is zero.
*
* @param x object for which the hashCode is to be calculated
* @return the hashCode
* @since JDK1.1
*/
public static native int identityHashCode(Object x);
}
以下は次からの引用です: HotSpot VM 内の Java オブジェクトおよびクラスの特定の実装の詳細な分析
オブジェクトハッシュ
_mark には、オブジェクトのハッシュ値を表すハッシュ コード フィールドがあります。各 Java オブジェクトには独自のハッシュ値があり、Object.hashCode() メソッドが書き換えられない場合、仮想マシンはそのハッシュ値を自動的に生成します。ハッシュ値生成の戦略をリスト 3-4 に示します。
コード リスト 3-4 オブジェクト ハッシュ値の生成戦略
static inline intptr_t get_next_hash(Thread * Self, oop obj) { intptr_t value = 0; if (hashCode == 0) { // Park-Miller 乱数発生器の値 = os::random(); } else if (hashCode = = 1) { // ランダムを行うために STW ごとに stwRandom を生成intptr_t addrBits = Cast_from_oop Java 層は Object.hashCode() または System.identityHashCode() を呼び出し、最後に仮想マシン層のランタイム/シンクロナイザーの get_next_hash() を呼び出して生成します。ハッシュ値。
1.2、キー、値の型
static final int TREEIFY_THRESHOLD = 8; //链表转红黑树
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判断table是否初始化
if ((tab = table) == null || (n = tab.length) == 0)
//如果是，调用 resize() 方法，进行初始化并赋值
n = (tab = resize()).length;
//通过hash获取下标，如果数据为null
if ((p = tab[i = (n - 1) & hash]) == null)
// tab[i]下标没有值，创建新的Node并赋值
tab[i] = newNode(hash, key, value, null);
else {
//tab[i] 下标的有数据，发生碰撞
Node<K,V> e; K k;
//判断tab[i]的hash值和传入的hash值相同，tab[i]的的key值和传入的key值相同
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//如果是key值相同直接替换即可
e = p;
else if (p instanceof TreeNode)//判断数据结构为红黑树
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//数据结构是链表
for (int binCount = 0; ; ++binCount) {
//p的下一个节点为null,表示p就是最后一个节点
if ((e = p.next) == null) {
//创建新的Node节点并插入链表的尾部
p.next = newNode(hash, key, value, null);
//当元素>=8-1，链表转为树(红黑树)结构
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果key在链表中已经存在，则退出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//更新p指向下一个节点，继续遍历
p = e;
}
}
//如果key在链表中已经存在，则修改其原先key的value值，并且返回老的value值
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);//替换旧值时会调用的方法(默认实现为空)
return oldValue;
}
}
++modCount;//修改次数
//根据map值判断是否要对map的大小扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);//插入成功时会调用的方法(默认实现为空)
return null;
}
putVal ソース コードを参照してください。key および vlaue データ型はジェネリックスを使用しており、任意の参照型が問題ありません (Java の基本型は許可されていません。基本的なデータ型は、比較のために hashcode() メソッドとquals() メソッドを呼び出すことができないため、 HashMap コレクションのキー。基本データ型ではなく、参照データ型のみにすることができます。Integer、Double、Long、Float などの基本データ型のラッパー クラスを使用できます。
1.3、ノード
[1.2] コード セクションを参照してください。タブ変数のタイプは、Map.Entry インターフェイスを実装する Node です。Node には、
ハッシュ、キー、値などの属性があり、次のノード変数 (リンク リスト) もあります。次のノード。この
ノードは、toString、hashCode、equals などのメソッドを実装します。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() {
return key; }
public final V getValue() {
return value; }
public final String toString() {
return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
interface Entry<K,V> {
K getKey();
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getKey().compareTo(c2.getKey());
}
public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getValue().compareTo(c2.getValue());
}
public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
}
public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp){
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
}
}
1.4、ツリーノード
[1.2] コード部分を参照してください。変数 p の型は LinkedHashMap.Entry インターフェイスを実装する TreeNode です。TreeNode にはred
などの属性と、parent、left、right、prev (赤黒ツリー) などの変数があります。
Treeify、find、putTreeVal などのメソッドを実装します。
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;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
...
}
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)
p = pr;
else if (pr == null)
p = pl;
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.find(h, k, kc)) != null)
return q;
else
p = pl;
} while (p != null);
return null;
}
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
}
static int tieBreakOrder(Object a, Object b) {
int d;
if (a == null || b == null ||
(d = a.getClass().getName().
compareTo(b.getClass().getName())) == 0)
d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
-1 : 1);
return d;
}
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;
root = balanceInsertion(root, x);
break;
}
}
}
}
moveRootToFront(tab, root);
}
final Node<K,V> untreeify(HashMap<K,V> map) {
Node<K,V> hd = null, tl = null;
for (Node<K,V> q = this; q != null; q = q.next) {
Node<K,V> p = map.replacementNode(q, null);
if (tl == null)
hd = p;
else
tl.next = p;
tl = p;
}
return hd;
}
/**
* Tree version of putVal.
*/
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
TreeNode<K,V> root = (parent != null) ? root() : this;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
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;
}
dir = tieBreakOrder(k, pk);
}
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
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;
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
boolean movable) {
...
}
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
...
}
/* ------------------------------------------------------------ */
// Red-black tree methods, all adapted from CLR
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
TreeNode<K,V> p) {
...
return root;
}
static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
TreeNode<K,V> p) {
...
return root;
}
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
...
}
static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,
TreeNode<K,V> x) {
...
}
static <K,V> boolean checkInvariants(TreeNode<K,V> t) {
...
return true;
}
}
1.5. データ挿入時のデータ構造の変更
[1.2] コードを参照してください。データを挿入すると、データ構造はどうなりますか?
エフェクトの画像は [1] の 2 番目の画像で見ることができます。
- テーブルが初期化されているかどうかを確認します。 はい
-> 初期化して割り当てるために、resize() メソッドを呼び出します。 - 初期化されていない場合は、ハッシュを通じて添字を取得します。データが null の場合は、
tab[i] 添字に値がありません。新しいノードを作成して割り当てます。 - tab[i]の添え字にデータがあり、ハッシュ衝突が発生する場合は3つのケースがあります。
1. tab[i]のハッシュ値が渡されたハッシュ値と同じであると判断する場合と、tab[i]のキー値を一致させる場合渡されたキー値と同じである 同じで
あれば直接置換
2. データ構造が赤黒ツリーであると判断
赤黒ツリーのデータ挿入関数 putTreeVal を呼び出す
3. データ構造はリンクされたリスト
循環リスト。p の次のノードが null の場合、p が最後のノードであることを意味します。最後に新しい Node ノードを挿入します。このとき要素数が 7 以上の場合、リンク リストは赤と黒のツリー構造に変わります。
キーがリンク リストに既に存在する場合は、ループを終了します。
2. 実験
実験にはハッシュの衝突と、赤と黒のツリーに変わるリンク リストが含まれています。ソース コードを段階的にデバッグしてトレースして確認してみましょう。
2.1. ハッシュの衝突
2.1.1とビット演算(&)
- 1. 文字列「A」、「B」、「C」、「D」、「E」、「F」、「G」、「H」のハッシュコードを計算します。
- 2. バイナリに変換 (https://jisuan5.com/decmal/?hex=356573597)
10 進数の 15 を 2 進数に変換、結果: 1111
"A" hashCode=356573597 この実験では、2 を 10 進数に変換 356573597 ベース、結果: 10101010000001110000110011 101
356573597 & 15
= 10101010000001110000110011101 & 1111
= 10101010000001110000110011101 & 000
00000000000000000000001111 (高補数 0、整列)左のデータ)
= 0000000000000000000000001101 = 1101 (上位0は省略可能) - 3. 15 (2 の 4 乗 -1) を他のデータに変更するいくつかの実験の後、2 -1 のべき乗、下位ビットはすべて 1 であり、AND 演算を実行するとデータが均等に分散されることがわかりました。 2 のべき乗または他のデータに変更すると、下位ビットに 0 があり、最終的なデータの分布は不均一になります。
int n = 16 - 1; //二进制: 1111
String[] strs = {
"A" , "B" , "C" , "D" , "E" , "F" , "G" , "H"};
for (int i = 0; i < strs.length; i++) {
System.out.println("-------------------------");
System.out.println(System.identityHashCode(strs[i]) );
System.out.println("二进制："+ Integer.toBinaryString(System.identityHashCode(strs[i])) );
System.out.println( System.identityHashCode(strs[i]) & n );
System.out.println("-------------------------");
}
-------------------------
356573597
二进制：10101010000001110000110011101
13
-------------------------
-------------------------
1735600054
二进制：1100111011100110010011110110110
6
-------------------------
-------------------------
21685669
二进制：1010010101110010110100101
5
-------------------------
-------------------------
2133927002
二进制：1111111001100010010010001011010
10
-------------------------
-------------------------
1836019240
二进制：1101101011011110110111000101000
8
-------------------------
-------------------------
325040804
二进制：10011010111111011101010100100
4
-------------------------
-------------------------
1173230247
二进制：1000101111011100001001010100111
7
-------------------------
-------------------------
856419764
二进制：110011000010111110110110110100
4
-------------------------
2.1.2. ハッシュの衝突
[2.1.1] のコードの場合、F と H のハッシュ値を 15 と AND 演算すると、値は 4 になります。詳細な説明は [1.5] を参照してください。これは、HashMap のインデックス位置を計算することに相当します。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
...
if ((p = tab[i = (n - 1) & hash]) == null)
...
}
ハッシュ衝突 (ハッシュ衝突) に対するいくつかの解決策を次に示します。
- チェーンアドレス方式
ハッシュ衝突が発生したデータは配列内で同じインデックスを持ち、リンクリストを使用して衝突したデータを格納します (JDK8 の HashMap はこの方式を採用し、末尾挿入方式を使用します)。 - 再ハッシュ法
ハッシュ衝突の問題が発生した場合、衝突が起こらなくなるまでここでハッシュする この方法は集計を生成するのが容易ではありませんが、計算時間が増加します - オープンアドレス方式
ハッシュ衝突問題が発生した場合、衝突が発生したユニットから一定の順序でハッシュテーブルから空きユニットを探します。競合する要素をセルに格納するメソッド。 - パブリックオーバーフロー領域を設ける
ハッシュテーブルをパブリックテーブルとオーバーフローテーブルに分割し、オーバーフローが発生した場合はオーバーフローデータを全てオーバーフロー領域に入れる
2.2. リンクリストが赤黒ツリーになる
2 つの仮定があるとします (HashMap では、デフォルトの負荷係数は 0.75 ですが、長さが 12 (16*0.75=12) を超える場合、長さは 32 に拡張され、ビット演算の再計算値も変更されます)。リバランス分散については、[1.5] を参照してください)
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
...
//p的下一个节点为null,表示p就是最后一个节点
if ((e = p.next) == null) {
//创建新的Node节点并插入链表的尾部
p.next = newNode(hash, key, value, null);
//当元素>=8-1，链表转为树(红黑树)结构
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
...
}
1. ハッシュ バケットは拡張されません。
2. (F, H...H8 ) & 15 はすべて 4 に等しく、合計 9 つの要素です。7 番目の要素が追加されると、リンク リストが次のようになります。赤黒ツリー H7 と H8 を挿入した場合、直接一般的な黒ツリー挿入ロジック
