独立链表是解决哈希冲突的一种办法。它的基本思想就是将哈希值相互冲突的几个对象放到一个链表中。

代码

public class HashST
  
    {
    private static class Node {
        Object key; // 由于无法创建泛型数组，只能将对象设置为Object类
        Object value;
        Node next;
 
        public Node(Object key, Object value, Node next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }
 
    private Node[] map;
    private static final int M = 97;
 
    public HashST() {
        map = new Node[M];
    }
 
    public Value get(Key key) {
        int hash = hash(key);
        Node node = map[hash];
        while(node != null) {
            if(key.equals(node.key)) {
                return (Value) node.value;
            }
            node = node.next;
        }
 
        // 没有找到
        return null;
    }
 
    public void put(Key key, Value value) {
        int hash = hash(key);
        Node node = map[hash];
        while(node != null) {
            if(key.equals(node.key)) {
                node.value = value;
                return;
            }
        }
        map[hash] = new Node(key, value, node);
    }
 
    private int hash(Key key) {
        return (key.hashCode() & 0x7fffffff) % M;
    }
}
  

性能

性能和M有关，M就是链表的数量。如果M过大，那么内存中就会有很多空的链表，如果M太小，那么每条链表就会很长，造成性能变差。所以，M一般取N/5，N就是关键字的数量。