键值表

什么是键值表

键值表是键值对集合，类似字典，支持存入键值对，按键查值等操作。

对外接口

• public void put(Key key, Value val);
• public Value get(Key key);
• public boolean contains(Key key);
• public Value remove(Key key);
• public int size();
• public boolean isEmpty();

接口代码

public interface IMap<Key, Value> {    /**     * 存入键值对     *      * @param key     *            键     * @param value     *            值     */    public void put(Key key, Value value);    /**     * 按鍵查值     *      * @param key     *            鍵     * @return 值     */    public Value get(Key key);    /**     * 判断是否包含某键     *      * @param key     *            键     * @return <code>true</code> 若包含；否则，<code>false</code>     */    public boolean contains(Key key);    /**     * 删除键为key的键值对     *      * @param key     *            键     */    public Value remove(Key key);    /**     * 返回键值对个数     *      * @return 键值对个数     */    public int size();    /**     * 判断键值表是否为空     *      * @return <code>true</code> 如果键值表为空；否则，<code>false</code>。     */    public boolean isEmpty();}

初级实现

package com.gmail.dailyefforts.ds;import java.util.HashMap;import java.util.Map;import java.util.Random;public class SimpleLinkedMap<Key, Value> implements IMap<Key, Value>{    private class Node {        private Node prev;        private Key key;        private Value val;        private Node next;        public Node(Node prev, Key key, Value val, Node next) {            this.prev = prev;            this.key = key;            this.val = val;            this.next = next;        }        @Override        public String toString() {            return String.format("%s=%s", String.valueOf(key),                    String.valueOf(val));        }    }    private int size;    private Node first;    private Node last;    @Override    public void put(Key key, Value val) {        for (Node x = first; x != null; x = x.next) {            if (key.equals(x.key)) {                x.val = val;                return;            }        }        Node oldLast = last;        last = new Node(last, key, val, null);        if (oldLast != null) {            oldLast.next = last;        }        size++;        if (first == null) {            first = last;        }    }    @Override    public Value remove(Key key) {        for (Node x = first; x != null; x = x.next) {            if (key.equals(x.key)) {                if (x.prev == null) {                    first = x.next;                } else {                    x.prev.next = x.next;                }                if (x.next == null) {                    last = x.prev;                } else {                    x.next.prev = x.prev;                }                size--;                return x.val;            }        }        return null;    }    @Override    public boolean contains(Key key) {        return get(key) != null;    }    @Override    public Value get(Key key) {        for (Node x = first; x != null; x = x.next) {            if (key.equals(x.key)) {                return x.val;            }        }        return null;    }    @Override    public int size() {        return size;    }    @Override    public boolean isEmpty() {        return size() == 0;    }    @Override    public String toString() {        StringBuilder builder = new StringBuilder();        builder.append('{');        for (Node x = first; x != null; x = x.next) {            builder.append(x);            if (x.next != null) {                builder.append(", ");            }        }        builder.append('}');        return builder.toString();    }    public static void main(String[] args) {        final int N = 100 * 100;        SimpleLinkedMap<Integer, String> map = new SimpleLinkedMap<>();        Map<Integer, String> map2 = new HashMap<>();        for (int i = 0; i < N; i++) {            Integer key = Integer.valueOf(i);            String value = "item-" + i;            map2.put(key, value);            map.put(key, value);        }//      System.out.println(map2);//      System.out.println(map);        Random random = new Random(System.currentTimeMillis());        for (int i = 0; i < N / 2; i++) {            final int key = random.nextInt(N);            final String a = map.remove(key);            final String b = map2.remove(key);            if (a == null) {                assert (b == null);            } else {                assert (a.equals(b));            }        }        assert(map.size() == map2.size());        for (int i = 0; i < N; i++) {            final String a = map.get(i);            final String b = map2.get(i);            if (a == null) {                assert (b == null);            } else {                assert (a.equals(b));            }        }    }}

Hash实现

在上面的初级实现中，每次查询都要遍历了整个字典，效率为O(n)。现实中，我们从字典中查询某个单词时，我们借助索引来提高效率，而不是从该字典收录的第一个词开始逐个遍历整个字典。
我们可以利用hash来建立索引，遇到索引相同时再用链表存储。

package com.gmail.dailyefforts.ds;import java.util.HashMap;import java.util.Map;import java.util.Random;public class MyHashMap<Key, Value> implements IMap<Key, Value> {    private int size;    private static final int M = 100 * 100;    private SimpleLinkedMap<Key, Value>[] a = (SimpleLinkedMap<Key, Value>[]) new SimpleLinkedMap[M];    @Override    public void put(Key key, Value value) {        SimpleLinkedMap<Key, Value> map = map(key);        if (!map.contains(key)) {            size++;        }        map.put(key, value);    }    private int hash(Key key) {        // [0, M]        return key.hashCode() & 0x7fffffff % M;    }    private SimpleLinkedMap<Key, Value> map(Key key) {        int index = hash(key);        if (a[index] == null) {            a[index] = new SimpleLinkedMap<Key, Value>();        }        return a[index];    }    @Override    public Value get(Key key) {        return map(key).get(key);    }    @Override    public boolean contains(Key key) {        return map(key).contains(key);    }    @Override    public Value remove(Key key) {        Value value = map(key).remove(key);        if (value != null) {            size--;        }        return value;    }    @Override    public int size() {        return this.size;    }    @Override    public String toString() {        return super.toString();    }    @Override    public boolean isEmpty() {        return size() == 0;    }    public static void main(String[] args) {        final int N = 100 * 100 * 100;        MyHashMap<Integer, String> map = new MyHashMap<>();        Map<Integer, String> mapRef = new HashMap<>();        for (int i = 0; i < N; i++) {            Integer key = Integer.valueOf(i);            String value = "item-" + i;            map.put(key, value);            mapRef.put(key, value);        }        assert(map.size() == mapRef.size());        Random random = new Random(System.currentTimeMillis());        for (int i = 0; i < N / 2; i++) {            final int key = random.nextInt(N);            assert (map.contains(key) == mapRef.containsKey(key));            final String a = map.remove(key);            final String b = mapRef.remove(key);            if (a == null) {                assert (b == null);            } else {                assert (a.equals(b));            }        }        assert (map.size() == mapRef.size());        for (int i = 0; i < N; i++) {            final int key = random.nextInt(N);            final String a = map.get(key);            final String b = mapRef.get(key);            if (a == null) {                assert (b == null);            } else {                assert (a.equals(b));            }        }        System.out.println("test passed");    }}