static final int DEFAULT_INITIAL_CAPACITY = 1 << 4：默認(rèn)的table初始容量
static final float DEFAULT_LOAD_FACTOR = 0.75f：默認(rèn)的負(fù)載因子

static final int TREEIFY_THRESHOLD = 8: 鏈表長度大于等于該參數(shù)轉(zhuǎn)紅黑樹
static final int UNTREEIFY_THRESHOLD = 6: 當(dāng)樹的節(jié)點數(shù)小于等于該參數(shù)轉(zhuǎn)成鏈表

transient Node<K,V>[] table：這是一個Node類型的數(shù)組（也有稱作Hash桶）

static class Node<K, V> {
    final int hash;       // 鍵的哈希值
    final K key;         // 鍵
    V value;             // 值
    Node<K, V> next;     // 指向下一個節(jié)點，處理鏈表沖突
}

import java.util.HashMap;

public class HashMapPerformanceTest {
    public static void main(String[] args) {
        int numberOfElements = 1_000_000; // 要插入的元素數(shù)量

        // 測試負(fù)載因子為默認(rèn)值 (0.75)
        long timeWithDefaultLoadFactor = testHashMapPerformance(0.75f, numberOfElements);
        System.out.println("Time taken with default load factor (0.75): " + timeWithDefaultLoadFactor + " ms");

        // 測試負(fù)載因子為 0.5
        long timeWithLowLoadFactor = testHashMapPerformance(0.5f, numberOfElements);
        System.out.println("Time taken with low load factor (0.5): " + timeWithLowLoadFactor + " ms");

        // 測試負(fù)載因子為 0.9
        long timeWithHighLoadFactor = testHashMapPerformance(0.9f, numberOfElements);
        System.out.println("Time taken with high load factor (0.9): " + timeWithHighLoadFactor + " ms");
    }

    private static long testHashMapPerformance(float loadFactor, int numberOfElements) {
        long startTime = System.currentTimeMillis();

        HashMap<Integer, String> map = new HashMap<>(16, loadFactor); // 初始化 HashMap
        
        // 插入元素
        for (int i = 0; i < numberOfElements; i++) {
            map.put(i, "Value " + i);
        }

        long endTime = System.currentTimeMillis();
        return endTime - startTime; // 返回耗時
    }
}

    //構(gòu)造一個空的HashMap，默認(rèn)初始容量16和負(fù)載因子0.75
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
 

//構(gòu)造一個指定初始容量的HashMap，默認(rèn)負(fù)載因子0.75。
   public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

//構(gòu)造一個指定的HashMap，指定默認(rèn)初始容量和負(fù)載因子
   public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

   //構(gòu)造一個映射的map 
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

import java.util.Arrays;

class MyHashMap<K, V> {
    static class Node<K, V> {
        final int hash; // 存儲哈希值
        final K key;    // 存儲鍵
        V value;        // 存儲值
        Node<K, V> next; // 指向下一個節(jié)點
        
        Node(int hash, K key, V value, Node<K, V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }

    private Node<K, V>[] table; // 存儲節(jié)點的數(shù)組
    private int size;            // 當(dāng)前大小
    private int threshold;       // 擴容閾值
    private float loadFactor;    // 負(fù)載因子

    public MyHashMap(int initialCapacity, float loadFactor) {
        this.loadFactor = loadFactor;
        this.table = new Node[initialCapacity];
        this.threshold = (int)(initialCapacity * loadFactor);
    }

    public void put(K key, V value) {
        int hash = key == null ? 0 : key.hashCode();
        int index = (hash & (table.length - 1)); // 計算桶的索引
        Node<K, V> existingNode = table[index];

        // 檢查桶是否為空
        if (existingNode == null) {
            // 如果桶為空，創(chuàng)建一個新節(jié)點
            table[index] = new Node<>(hash, key, value, null);
            size++;
        } else {
            // 遍歷鏈表，檢查是否已有相同的鍵
            Node<K, V> currentNode = existingNode;
            while (true) {
                if (currentNode.hash == hash && (currentNode.key == key || (key != null && key.equals(currentNode.key)))) {
                    // 找到相同的鍵，更新值
                    currentNode.value = value;
                    return;
                }
                if (currentNode.next == null) {
                    // 沒有找到，添加新節(jié)點
                    currentNode.next = new Node<>(hash, key, value, null);
                    size++;
                    break;
                }
                currentNode = currentNode.next;
            }
        }

        // 檢查是否需要擴容
        if (size >= threshold) {
            resize();
        }
    }

    private void resize() {
        // 擴容邏輯，目前省略具體實現(xiàn)
    }
}

int hash = key.hashCode();
// 分兩次右移，并進行異或，減少碰撞
hash ^= (hash >>> 16);

int index = (hash & (table.length - 1));

class Node<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 class MyHashMap<K, V> {
    private Node<K, V>[] table; // 存儲節(jié)點的數(shù)組
    private int size;

    public MyHashMap(int initialCapacity) {
        this.table = new Node[initialCapacity];
    }

    public V get(K key) {
        if (key == null) {
            return null; // 處理空鍵
        }
        
        int hash = key.hashCode(); // 計算哈希值
        int index = (hash & (table.length - 1)); // 計算索引

        Node<K, V> node = table[index]; // 獲取對應(yīng)的桶

        // 遍歷鏈表或紅黑樹
        while (node != null) {
            if (node.hash == hash && (node.key.equals(key))) {
                return node.value; // 找到鍵，返回對應(yīng)的值
            }
            node = node.next; // 移動到下一個節(jié)點
        }

        return null; // 未找到
    }
}

public class HashMapDemo {
    public static void main(String[] args) {
        MyHashMap<String, Integer> map = new MyHashMap<>(4, 0.75f); // 初始化容量為4，負(fù)載因子為0.75
        
       map.put("one", 1); → 當(dāng)前大小為 1（沒有觸發(fā)擴容）。
       map.put("two", 2); → 當(dāng)前大小為 2（沒有觸發(fā)擴容）。
       map.put("three", 3); → 當(dāng)前大小為 3（這時已達到閾值，因此將觸發(fā)擴容）。
       map.put("four", 4); → 由于已經(jīng)擴容，實際中會發(fā)生元素的重新分配，現(xiàn)在當(dāng)前數(shù)組的大小為 4。
       map.put("five", 5); → 當(dāng)前大小為 5 (但是不會再觸發(fā)擴容，因為數(shù)組容量已增加到 8)。
        
        // 你可以擴展上面代碼來實現(xiàn) get 方法等
    }
}

package com.example.test;

import java.lang.reflect.Field;
import java.util.HashMap;

public class HashMapTest {
    public static void main(String[] args) {
        HashMap<String, Object> map = new HashMap<>(4,0.75f);
        map.put("one",1);
        map.put("two",2);
        map.put("three",3);
        map.put("four",4);
        try {
            // 獲取底層數(shù)組長度
            Field tableField = HashMap.class.getDeclaredField("table");
            tableField.setAccessible(true);
            Object[] table = (Object[]) tableField.get(map);

            System.out.println("鍵值對數(shù)量(map.size): " + map.size());
            System.out.println("底層數(shù)組長度: " + (table != null ? table.length : 0));
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
        System.out.println("map.size="+map.size());
    }
}

// 正確方式（使用迭代器的remove）
Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
    if (it.next().equals("remove")) {
        it.remove();  // 不會增加modCount
    }
} 這個是正常的，  Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);

Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
    String key = it.next();
    map.put("C", 3);  // 這里會觸發(fā)fail-fast
} 而這個會觸發(fā)fail-fast

// HashMap.HashIterator.remove()
public final void remove() {
    Node<K,V> 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; // 關(guān)鍵點：同步更新！
}

// HashMap.put()
public V put(K key, V value) {
    // ...省略其他代碼...
    ++modCount; // 修改計數(shù)器增加
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

// HashIterator.nextNode()
final Node<K,V> nextNode() {
    if (modCount != expectedModCount) // 此時不相等！
        throw new ConcurrentModificationException();
    // ...
}

// 安全刪除示例
List<String> toRemove = new ArrayList<>();
for (Entry<String, Integer> entry : map.entrySet()) {
    if (entry.getValue() < 0) {
        toRemove.add(entry.getKey());
    }
}
toRemove.forEach(map::remove); // 迭代完成后再批量刪除

// 使用ConcurrentHashMap
ConcurrentHashMap<String, Integer> safeMap = new ConcurrentHashMap<>();
// 迭代時修改不會拋異常
for (String key : safeMap.keySet()) {
    if (key.startsWith("test")) {
        safeMap.remove(key); // 安全操作
    }
}