每日一省之————利用数组和链表实现一个简单的HashMap

今天本人想要复习的是哈希表（散列表）的概念及具体实现，为此用java写了一个简单的实现，但仅仅只是实现了一些简单的功能，不过通过这个简单的实现的确可以帮助我们进一步理解JDK中的HashMap，当然，想要进一步了解就直接阅读JDK中的HashMap的源码啦。

实现代码如下，有注释，本人就不进一步阐述了：

/** * 该类是HashMap的一个简单实现。 *  * 这里，我主要采用一个元素是链表的数组来模拟JDK中的HashMap实现。 当存入一个键值对（K,V）的时候，首先计算键（K）对应的HashCode。这个HashCode的值其实就是具体实现过程中用到的数组的索引。通过计算键的HashCode值便可以知道应该将键值对（K,V）存储在第几个数组元素中。如前所述，每一个数组元素其实又是一个链表。将键值对存入散列表其实是存入底层数组元素对应的链表结构中。之所以使用链表作为数组元素是为了避免HashCode相同但又不相等的键造成冲突时候相互覆盖的问题。这样就很好的解决了可能存在的碰撞冲突问题。 *  * @author lhever * * @param <K> * @param <V> */public class SimpleHashMap<K, V> {    public static final int INITIAL_CAPACITY = 4;    private int N;    private int M;    private SequentialST<K, V>[] table;    /**     * 构造     */    public SimpleHashMap() {        this(INITIAL_CAPACITY);    }    /**     * 构造，可以指定底层数组的大小     *      * @param M     */    public SimpleHashMap(int M) {        this.M = M;        table = (SequentialST<K, V>[]) new SequentialST[M];        for (int i = 0; i < M; i++) {            table[i] = new SequentialST<K, V>();        }    }    /**     * 重新调整底层数组的大小，从实现的角度看，所有已经 存入的键值对会被从新计算散列值并调整存储的位置。     *      * @param newSize     */    private void resize(int newSize) {        SimpleHashMap<K, V> temp = new SimpleHashMap<K, V>(newSize);        for (int i = 0; i < M; i++) {            for (K key : table[i].keys()) {                temp.put(key, table[i].get(key));            }        }        this.M = temp.M;        this.N = temp.N;        this.table = temp.table;    }    private int hash(K key) {        return (key.hashCode() & 0x7fffffff) % M;    }    public int size() {        return N;    }    public boolean isEmpty() {        return size() == 0;    }    public boolean contains(K key) {        if (key == null) {            throw new NullPointerException("参数不能为null");        }        return get(key) != null;    }    public V get(K key) {        if (key == null) {            throw new NullPointerException("参数不能为null");        }        int i = hash(key);        return table[i].get(key);    }    public void put(K key, V val) {        if (key == null) {            throw new NullPointerException("key不能为null");        }        if (val == null) {            remove(key);            return;        }        // 当链表中的平均元素个数大于10的时候增加底层数组的大小（变为两倍大）        if (N >= 10 * M) {            resize(2 * M);        }        int i = hash(key);        if (!table[i].contains(key)) {            N++;        }        table[i].put(key, val);    }    public void remove(K key) {        if (key == null) {            throw new NullPointerException("参数不能为null");        }        int i = hash(key);        if (table[i].contains(key)) {            N--;            table[i].delete(key);        }        // 如果列表中的平均元素个数小于等于2的时候，降低底层数组的大小（变为原来大小的1/2）        if (M > INITIAL_CAPACITY && N <= 2 * M) {            resize(M / 2);        }    }    // 返回一个迭代器，其中包含了所有的键    public Iterable<K> keys() {        Queue<K> queue = new LinkedList<K>();        for (int i = 0; i < M; i++) {            for (K key : table[i].keys())                queue.offer(key);        }        return (Iterable<K>) queue;    }    /**     * 测试     *      * @param args     */    public static void main(String... args) {        SimpleHashMap map = new SimpleHashMap<String, String>();        map.put("country", "China");        map.put("level", "super");        map.put("nature", "public");        System.out.println(map.get("country"));        System.out.println("befor remove, the size is: " + map.size());        map.remove("country");        System.out.println("after remove, the size is: " + map.size());        for (String key : (Iterable<String>) map.keys()) {            System.out.println(key + " : " + map.get(key));        }        map.remove("nature");        map.remove("level");        map.remove("level");        System.out.println("after remove, the size is: " + map.size());        for (String key : (Iterable<String>) map.keys()) {            System.out.println(key + " : " + map.get(key));        }        map.put("size", "960");        System.out.println("after put, the size is: " + map.size());    }}////////////////////////////////////////////////////package lhever.Hash_Map;import java.util.LinkedList;import java.util.Queue;/** * 该类是一个顺序查找的链表实现，查找元素时候会从第一个节点开始顺序查找， * 该链表实现会被用到SimpleHashMap（JDK中HashMap的一个简单实现）的实现中 *  * @author lhever * * @param <K> * @param <V> */public class SequentialST<K, V> {    private int N;    private Node first;    /**     * 代表一个节点     *      * @author lhever     */    private class Node {        private K key;        private V value;        private Node next;        public Node(K key, V value, Node next) {            this.key = key;            this.value = value;            this.next = next;        }    }    public SequentialST() {    }    public int size() {        return N;    }    public boolean isEmpty() {        return size() == 0;    }    public boolean contains(K key) {        if (key == null)            throw new NullPointerException("参数不能为null");        return get(key) != null;    }    /**     * 查找从第一个节点开始顺序进行     *      * @param key     * @return     */    public V get(K key) {        if (key == null)            throw new NullPointerException("参数不能为null");        for (Node node = first; node != null; node = node.next) {            if (key.equals(node.key))                return node.value;        }        return null;    }    /**     * 增加     *      * @param key     * @param value     */    public void put(K key, V value) {        if (key == null)            throw new NullPointerException("参数不能为null");        if (value == null) {            delete(key);            return;        }        for (Node node = first; node != null; node = node.next) {            if (key.equals(node.key)) {                node.value = value;                return;            }        }        first = new Node(key, value, first);        N++;    }    public void delete(K key) {        if (key == null)            throw new NullPointerException("参数不能为null");        first = delete(first, key);    }    private Node delete(Node node, K key) {        if (node == null)            return null;        if (key.equals(node.key)) {            N--;            return node.next;        }        node.next = delete(node.next, key);        return node;    }    public Iterable<K> keys() {        Queue<K> queue = new LinkedList<K>();        for (Node node = first; node != null; node = node.next)            queue.offer(node.key);        return queue;    }}