每日一省之————利用数组和链表实现一个简单的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;
}

}