优化HashMap的put方法实现：深入理解键值替换与新增逻辑

for (int i = 0; i < buckets.length; i += 1) {
    buckets[i] = new ArrayList<HashMapEntry<K, V>>();
}

// 假设 buckets[index] 是一个 ArrayList<HashMapEntry<K, V>>
if (buckets[index].equals(key)) {
    // ... 错误逻辑
}

import java.util.ArrayList;
import java.util.Objects; // 用于Objects.equals()

public class MyHashMap<K, V> implements DefaultMap<K, V> {
    private ArrayList<HashMapEntry<K, V>>[] buckets;
    private int size; // 当前HashMap中存储的键值对数量
    private int capacity; // 桶数组的容量
    private double loadFactor; // 负载因子

    // 假设构造函数已正确初始化 buckets 数组中的每个 ArrayList
    // 示例构造函数
    @SuppressWarnings("unchecked")
    public MyHashMap(int initialCapacity, double loadFactor) {
        if (initialCapacity <= 0) {
            throw new IllegalArgumentException("Initial capacity must be positive.");
        }
        if (loadFactor <= 0 || Double.isNaN(loadFactor) || Double.isInfinite(loadFactor)) {
            throw new IllegalArgumentException("Load factor must be a positive finite number.");
        }
        this.capacity = initialCapacity;
        this.loadFactor = loadFactor;
        this.buckets = (ArrayList<HashMapEntry<K, V>>[]) new ArrayList[capacity];
        for (int i = 0; i < capacity; i++) {
            buckets[i] = new ArrayList<>(); // 初始化每个桶为一个空的ArrayList
        }
        this.size = 0;
    }

    @Override
    public boolean put(K key, V value) throws IllegalArgumentException {
        // 1. 处理空键
        if (key == null) {
            throw new IllegalArgumentException("Key cannot be null.");
        }

        // 2. 计算哈希值和索引
        int keyHash = key.hashCode();
        // 使用 Math.abs() 防止负哈希值导致数组越界，并取模获取索引
        int index = Math.abs(keyHash % capacity);

        // 获取目标桶
        ArrayList<HashMapEntry<K, V>> targetBucket = buckets[index];

        // 3. 遍历桶，检查键是否存在并进行替换
        for (HashMapEntry<K, V> entry : targetBucket) {
            // 使用 Objects.equals() 比较键，可以安全处理key为null的情况（虽然我们已在开头检查）
            if (Objects.equals(key, entry.getKey())) {
                entry.setValue(value); // 键已存在，更新其值
                return true; // 表示成功替换
            }
        }

        // 4. 键不存在，添加新条目
        targetBucket.add(new HashMapEntry<>(key, value));
        size++; // 增加HashMap的大小

        // 5. 检查负载因子并扩容
        // 当元素数量达到或超过 (容量 * 负载因子) 时进行扩容
        if ((double) size / capacity >= loadFactor) {
            expandCapacity(); // 执行扩容操作
        }
        return true; // 表示成功添加新条目
    }

    @Override
    public V get(K key) {
        // 示例：get 方法的实现
        if (key == null) {
            throw new IllegalArgumentException("Key cannot be null.");
        }
        int index = Math.abs(key.hashCode() % capacity);
        ArrayList<HashMapEntry<K, V>> targetBucket = buckets[index];
        for (HashMapEntry<K, V> entry : targetBucket) {
            if (Objects.equals(key, entry.getKey())) {
                return entry.getValue();
            }
        }
        return null; // 未找到键
    }

    @Override
    public boolean containsKey(K key) {
        // 示例：containsKey 方法的实现
        if (key == null) {
            throw new IllegalArgumentException("Key cannot be null.");
        }
        int index = Math.abs(key.hashCode() % capacity);
        ArrayList<HashMapEntry<K, V>> targetBucket = buckets[index];
        for (HashMapEntry<K, V> entry : targetBucket) {
            if (Objects.equals(key, entry.getKey())) {
                return true;
            }
        }
        return false;
    }

    @Override
    public V remove(K key) {
        // 示例：remove 方法的实现
        if (key == null) {
            throw new IllegalArgumentException("Key cannot be null.");
        }
        int index = Math.abs(key.hashCode() % capacity);
        ArrayList<HashMapEntry<K, V>> targetBucket = buckets[index];
        HashMapEntry<K, V> entryToRemove = null;
        for (HashMapEntry<K, V> entry : targetBucket) {
            if (Objects.equals(key, entry.getKey())) {
                entryToRemove = entry;
                break;
            }
        }
        if (entryToRemove != null) {
            targetBucket.remove(entryToRemove);
            size--;
            return entryToRemove.getValue();
        }
        return null; // 未找到键
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    // 内部类 HashMapEntry (示例)
    private static class HashMapEntry<K, V> {
        private K key;
        private V value;

        public HashMapEntry(K key, V value) {
            this.key = key;
            this.value = value;
        }

        public K getKey() { return key; }
        public V getValue() { return value; }
        public void setValue(V value) { this.value = value; }
    }

    // DefaultMap 接口的占位符，实际可能包含更多方法
    interface DefaultMap<K, V> {
        boolean put(K key, V value);
        V get(K key);
        boolean containsKey(K key);
        V remove(K key);
        int size();
        boolean isEmpty();
    }

    // expandCapacity() 方法的占位符，实际实现会创建一个更大的新数组并重新哈希所有条目
    @SuppressWarnings("unchecked")
    private void expandCapacity() {
        System.out.println("HashMap 正在扩容，当前容量: " + capacity + "，新容量: " + capacity * 2);
        int oldCapacity = capacity;
        capacity *= 2; // 通常将容量翻倍
        ArrayList<HashMapEntry<K, V>>[] oldBuckets = buckets;
        buckets = (ArrayList<HashMapEntry<K, V>>[]) new ArrayList[capacity];
        for (int i = 0; i < capacity; i++) {
            buckets[i] = new ArrayList<>(); // 初始化新桶
        }
        size = 0; // 重新计算size，因为put会增加size

        // 重新哈希所有旧条目到新桶中
        for (ArrayList<HashMapEntry<K, V>> bucket : oldBuckets) {
            if (bucket != null) {
                for (HashMapEntry<K, V> entry : bucket) {
                    put(entry.getKey(), entry.getValue()); // 使用put方法重新插入，会处理size和扩容
                }
            }
        }
    }
}