Java写哈希表的完整实例代码

class Node {
    Object key;
    Object value;
    Node next;

    // 构造方法：初始化键值对，next默认null
    public Node(Object key, Object value) {
        this.key = key;
        this.value = value;
        this.next = null;
    }
}

class LinkList {
    // 链表头节点
    private Node head;

    // 添加/覆盖键值对：存在相同key则覆盖value，不存在则新增节点
    public void add(Object key, Object value) {
        // 头节点为空，直接创建新节点作为头节点
        if (head == null) {
            head = new Node(key, value);
            return;
        }

        // 遍历链表，查找是否存在相同key
        Node current = head;
        while (current != null) {
            // key相等（处理null key），覆盖value
            if (equals(key, current.key)) {
                current.value = value;
                return;
            }
            // 到链表尾部，退出循环
            if (current.next == null) {
                break;
            }
            current = current.next;
        }

        // 无相同key，在链表尾部新增节点
        current.next = new Node(key, value);
    }

    // 根据key获取对应value，无则返回null
    public Object get(Object key) {
        Node current = head;
        while (current != null) {
            // 匹配key（处理null key）
            if (equals(key, current.key)) {
                return current.value;
            }
            current = current.next;
        }
        // 未找到对应key
        return null;
    }

    // 辅助方法：判断两个key是否相等（处理null值）
    private boolean equals(Object k1, Object k2) {
        if (k1 == null && k2 == null) {
            return true;
        }
        if (k1 == null || k2 == null) {
            return false;
        }
        return k1.equals(k2);
    }
}

public class MyHashMap {
    //定义保存链表的数组
    public LinkList[] linkLists;
    public static int len = 16;

    //自定义长度
    public MyHashMap(int len) {
        linkLists = new LinkList[len];
        //初始化数组，每个位置都创建空链表
        for(int i=0;i<len;i++){
            linkLists[i] = new LinkList();
        }
    }

    //默认长度
    public MyHashMap() {
        this(len);
    }

    //put数据：存储键值对，键重复则覆盖值
    public void put(Object key, Object value) {
        //根据当前key,利用哈希函数计算位置
        int index = hash(key);
        //取出对应链表,保存键值对（处理重复键覆盖）
        linkLists[index].add(key, value);
    }

    //get 取出数据：根据key获取对应value，无则返回null
    public Object get(Object key){
        int index = hash(key);
        return linkLists[index].get(key);
    }

    //哈希函数(散列函数)：计算key在数组中的索引，处理负数哈希值
    public int hash(Object key) {
        if (key == null) {
            return 0; // null键固定放在索引0位置
        }
        int hashCode = key.hashCode();
        // 处理负数哈希值，保证索引非负
        return (hashCode & 0x7FFFFFFF) % linkLists.length;
    }

    public static void main(String[] args) {
        MyHashMap hm = new MyHashMap();
        hm.put("a",10);
        hm.put("a",20); // 重复key，覆盖值
        hm.put("c",null);
        hm.put(null, 99); 

        System.out.println(hm.get("a"));  
        System.out.println(hm.get("c"));  
        System.out.println(hm.get(null)); 
        System.out.println(hm.get("d"));  
    }
}