什么是键值表
键值表是键值对集合，相似字典，支持存入键值对，按键查值等操作。
对外接口
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();
}
0基础实现
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实现
在上面的0基础实现中。每次查询都要遍历了整个字典。效率为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");
}
}
