优化哈希表 put 方法实现：解决常见逻辑错误与键值更新策略

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

if (buckets[index].equals(key)) {
    // ...
}

if (key == null) {
    throw new IllegalArgumentException("Key cannot be null.");
}

int keyHash = key.hashCode();
int index = Math.abs(keyHash % capacity); // capacity 是哈希表容量

// 假设 buckets 数组已被初始化，每个元素都是一个 ArrayList
// 例如，在构造函数中: buckets = new ArrayList[capacity];
// for (int i = 0; i < capacity; i++) { buckets[i] = new ArrayList<>(); }

// 遍历目标桶中的所有条目
for (HashMapEntry<K, V> entry : buckets[index]) {
    // 使用键的 equals 方法判断是否相等
    if (entry.getKey().equals(key)) {
        entry.setValue(value); // 键已存在，更新其值
        return true;           // 返回 true，表示键已存在并被更新
    }
}

// 如果循环结束仍未找到键，说明键不存在，需要添加新条目
buckets[index].add(new HashMapEntry<K, V>(key, value));
size++; // 增加哈希表中的元素数量

// 返回 false，表示键是新的，已添加
return false;

// ... (前述步骤)

// 如果循环结束仍未找到键，说明键不存在，需要添加新条目
buckets[index].add(new HashMapEntry<K, V>(key, value));
size++; // 增加哈希表中的元素数量

// 检查负载因子，决定是否需要扩容
// 注意：(double)size / capacity 是正确的计算方式，避免整数除法截断
if ((double) size / capacity >= loadFactor) {
    expandCapacity(); // 调用扩容方法
}

return false; // 返回 false，表示键是新的，已添加

import java.util.ArrayList;
import java.util.Objects; // For Objects.equals() in HashMapEntry

// 假设 HashMapEntry 类定义如下
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;
    }

    // 建议重写 equals 和 hashCode 方法，以确保键的正确比较
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        HashMapEntry<?, ?> that = (HashMapEntry<?, ?>) o;
        return Objects.equals(key, that.key);
    }

    @Override
    public int hashCode() {
        return Objects.hash(key);
    }
}

public class MyHashMap<K, V> {
    private ArrayList<HashMapEntry<K, V>>[] buckets;
    private int capacity;
    private int size;
    private double loadFactor;
    private static final double DEFAULT_LOAD_FACTOR = 0.75;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public MyHashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    public MyHashMap(int initialCapacity, double loadFactor) {
        this.capacity = initialCapacity;
        this.loadFactor = loadFactor;
        this.size = 0;
        // 初始化 buckets 数组，并为每个桶创建 ArrayList
        buckets = new ArrayList[capacity];
        for (int i = 0; i < capacity; i++) {
            buckets[i] = new ArrayList<>();
        }
    }

    /**
     * 将指定的键值对添加到此映射中。
     * 如果映射中已存在此键，则用新值替换旧值。
     *
     * @param key   要关联指定值的键。
     * @param value 与指定键关联的值。
     * @return 如果键已存在于此映射中并被更新，则返回 true；否则返回 false。
     * @throws IllegalArgumentException 如果键为 null。
     */
    public boolean put(K key, V value) throws IllegalArgumentException {
        if (key == null) {
            throw new IllegalArgumentException("Key cannot be null.");
        }

        int keyHash = key.hashCode();
        // 确保索引为非负数
        int index = Math.abs(keyHash % capacity);

        // 遍历目标桶中的所有条目，查找键是否存在
        for (HashMapEntry<K, V> entry : buckets[index]) {
            if (entry.getKey().equals(key)) {
                entry.setValue(value); // 键已存在，更新其值
                return true;           // 返回 true，表示键已存在并被更新
            }
        }

        // 如果循环结束仍未找到键，说明键不存在，添加新条目
        buckets[index].add(new HashMapEntry<K, V>(key, value));
        size++; // 增加哈希表中的元素数量

        // 检查负载因子，决定是否需要扩容
        // 当元素数量达到容量 * 负载因子时，进行扩容
        if ((double) size / capacity >= loadFactor) {
            expandCapacity();
        }

        return false; // 返回 false，表示键是新的，已添加
    }

    /**
     * 扩容方法：创建一个更大的数组，并将所有现有条目重新哈希并插入到新数组中。
     * (此处仅为示例，实际实现需要将所有旧桶中的元素重新哈希到新桶中)
     */
    private void expandCapacity() {
        int oldCapacity = capacity;
        capacity *= 2; // 通常将容量翻倍
        ArrayList<HashMapEntry<K, V>>[] oldBuckets = buckets;

        // 创建新的桶数组并初始化
        buckets = new ArrayList[capacity];
        for (int i = 0; i < capacity; i++) {
            buckets[i] = new ArrayList<>();
        }

        size = 0; // 重置 size，因为 put 操作会重新计数

        // 将旧桶中的所有元素重新插入到新桶中
        for (ArrayList<HashMapEntry<K, V>> bucket : oldBuckets) {
            for (HashMapEntry<K, V> entry : bucket) {
                // 调用 put 方法来重新插入，但需要一个不触发再次扩容的 put 版本
                // 或者直接实现重新哈希逻辑
                // 为了简化示例，这里假设有一个内部方法或直接实现逻辑
                rehashEntry(entry.getKey(), entry.getValue());
            }
        }
    }

    // 辅助方法，用于扩容时重新哈希条目，不触发负载因子检查和扩容
    private void rehashEntry(K key, V value) {
        int keyHash = key.hashCode();
        int index = Math.abs(keyHash % capacity);
        buckets[index].add(new HashMapEntry<>(key, value));
        size++; // 重新计数
    }

    // 其他哈希表方法，如 get, remove, containsKey 等...
    public int size() {
        return size;
    }

    public int getCapacity() {
        return capacity;
    }
}