同样是为了解决哈希表中索引重复问题的算法，基本思路为将哈希表中维护的数组改成存储链表的数组，将数据存在链表中。也可以用数组但是数组的插入和删除的效率较低，故采用链表。

实现：

链表的实现：

/*
 * 链结点，相当于是车厢
 */
public class Node {
    //数据域
    public Info info;
    //指针域
    public Node next;
    
    public Node(Info info) {
        this.info = info;
    }
    
}

/*
 * 链表，相当于火车
 */
public class LinkList {
    //头结点
    private Node first;
    
    public LinkList() {
        first = null;
    }
    
    /**
     * 插入一个结点，在头结点后进行插入
     */
    public void insertFirst(Info info) {
        Node node = new Node(info);
        node.next = first;
        first = node;
    }
    
    /**
     * 删除一个结点，在头结点后进行删除
     */
    public Node deleteFirst() {
        Node tmp = first;
        first = tmp.next;
        return tmp;
    }
    
    
    /**
     * 查找方法
     */
    public Node find(String key) {
        Node current = first;
        while(!key.equals(current.info.getKey())) {
            if(current.next == null) {
                return null;
            }
            current = current.next;
        }
        return current;
    }
    
    /**
     * 删除方法，根据数据域来进行删除
     */
    public Node delete(String key) {
        Node current = first;
        Node previous = first;
        while(!key.equals(current.info.getKey())) {
            if(current.next == null) {
                return null;
            }
            previous = current;
            current = current.next;
        }
        
        if(current == first) {
            first = first.next;
        } else {
            previous.next = current.next;
        }
        return current;
        
    }
}

哈希表的实现：

public class HashTable {
    private LinkList[] arr;
    
    /**
     * 默认的构造方法
     */
    public HashTable() {
        arr = new LinkList[100];
    }
    
    /**
     * 指定数组初始化大小
     */
    public HashTable(int maxSize) {
        arr = new LinkList[maxSize];
    }
    
    /**
     * 插入数据
     */
    public void insert(Info info) {
        //获得关键字
        String key = info.getKey();
        //关键字所自定的哈希数
        int hashVal = hashCode(key);
        if(arr[hashVal] == null) {
            arr[hashVal] = new LinkList();
        }
        arr[hashVal].insertFirst(info);
    }
    
    /**
     * 查找数据
     */
    public Info find(String key) {
        int hashVal = hashCode(key);
        return arr[hashVal].find(key).info;
    }
    
    /**
     * 删除数据
     * @param key
     * @return
     */
    public Info delete(String key) {
        int hashVal = hashCode(key);
        return arr[hashVal].delete(key).info;
    }
    
    public int hashCode(String key) {
        BigInteger hashVal = new BigInteger("0");
        BigInteger pow27 = new BigInteger("1");
        for(int i = key.length() - 1; i >= 0; i--) {
            int letter = key.charAt(i) - 96;
            BigInteger letterB = new BigInteger(String.valueOf(letter));
            hashVal = hashVal.add(letterB.multiply(pow27));
            pow27 = pow27.multiply(new BigInteger(String.valueOf(27)));
        }
        return hashVal.mod(new BigInteger(String.valueOf(arr.length))).intValue();
    }
}

所存储的实体类：

/**
 * 员工信息类
 * @author Administrator
 *
 */
public class Info {
    private String key;
    private String name;
    
    public Info(String key, String name) {
        this.key = key;
        this.name = name;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}