本文实例讲述了Java实现简易HashMap功能。分享给大家供大家参考，具体如下：
创建节点类
节点类含有的属性：键值对（value，key）以及指向下一节点的next；
这些属性的get以及set方法
代码如下：
/**
* 节点类
* @author HP
*
*/
public class Node {
private Object value;
private Object key;
private Node next;
/**
* 空节点
*/
public Node() {
}
/**
* 值为key value的节点
* @param data
*/
public Node(Object key,Object value) {
this.key = key;
this.value = value;
}
//接下来就是一些数据和节点的set，get
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
public Object getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
实现MyHash
实现MyHash的基本操作：
实现哈希表的基本存取运算
- 1.创建一个固定大小数组
- 2.将数组中的每个元素作为头节点
- 存储键值对
- 3.存数：通过对key某种运算，计算出该数的哈希码，将该哈希码与数组做某种运算，得到该数在数组中的哪一个位置下的链表中
- 4.取数：计算该数的哈希码，然后同样找到该数在数组中的位置，然后从该头节点依次向下进行比较得到该数，不存在则返回null
HashMap的源代码以及函数使用方法及返回值：
HashMap hash = new HashMap();
hash.keySet()
hash.hashCode() :返回int类型
hash.put(Object key, Object value)
hash.get(Object key)返回key值对应的value
hash.remove(key) 返回对应的value
hash.remove(key, value) 返回boolean是否remove成功
hash.size() :返回int类型的存储的节点的个数
hash.containsKey(Object key) :boolean
hash.containsValue(value) :boolean
hash.values() :返回value集合
hash.clear();
hash.replace(key, oldValue, newValue) ???
hash.replace(key, value) 将key对应的oldvalue换为传入的参数value，返回oldvalue
hash.entrySet()
hash.isEmpty()
hash.equals(o)：判断两个对象是否相等，看系统源代码，可重写
遍历Iterator输出的是所有节点对应的value的值
存储的东西越来越大，那么删除插入操作越来越复杂,那么需要rehash（需要一个条件判断是否需要rehash）
本次示例没有编写rehash函数。
MyHash代码，注释还比较详细，后边还有测试代码以及测试结果：
public class MyHash {
//哈希数组的长度初始化为8
private int size = 8;
private int number = 0;//存储的节点的个数
//哈希数组
private ArrayList<LinkedList> array_head = new ArrayList<LinkedList>(size);
//构造方法
public MyHash() {
for(int i=0;i<size;i++) {
LinkedList mylist = new LinkedList();//哈希数组中初始化存储的为空链表头
array_head.add(mylist);//初始化的时候就将空节点头添加到数组中去
}
}
/**
* 根据 键值对 生成节点
* 将节点放入哈希表中
* @param key 键
* @param value 值
*/
public void put(Object key,Object value) {
if(number/size == 10) {
rehash();
}
number++;
Node new_node = new Node(key,value);//由传入的参数生成新节点
int code = hashcode(key.toString());//得到哈希码
int position = locate(code);//得到该哈希码所对应的哈希数组中的位置
//找到该位置对应的链表头
LinkedList list_head = (LinkedList) array_head.get(position);
//将节点放入哈希表中
list_head.add(new_node);
}
/**
*
*/
private void rehash() {
}
/**
* @param key
* @param value
* @return 返回键值对应得节点
*/
public Object get(Object key) {
int code = hashcode(key.toString());//得到哈希码
int position = locate(code);//得到该哈希码所对应的哈希数组中的位置
//找到该位置对应的链表
LinkedList list_head = (LinkedList) array_head.get(position);
//从头遍历链表 ，找到与键key对应的节点的value值进行输出
for(int i=0;i<list_head.size();i++) {
//首先拿到头节点
Node head = (Node) list_head.get(i);
Node node = head;
while(node!=null) {
//如果 键 相等
if(node.getKey().equals(key)) {
// System.out.println(\"node.getValue() :\"+node.getValue());
return node.getValue();
}
node = node.getNext();
}
}
return null;//否则返回空
}
/**
* 移除键为key的节点
* @param key
* @return 返回删除节点的key对应的value
*/
public Object remove(Object key) {
number--;
int code = hashcode(key.toString());//得到哈希码
int position = locate(code);//得到该哈希码所对应的哈希数组中的位置
//找到该位置对应的链表
LinkedList list_head = (LinkedList) array_head.get(position);
//从头遍历链表 ，找到与键key对应的节点的value值进行输出
for(int i=0;i<list_head.size();i++) {
//首先拿到头节点
Node head = (Node) list_head.get(i);
Node node = head;
while(node!=null) {
//如果 键 相等
if(node.getKey().equals(key)) {
Object value = node.getValue();
list_head.remove(node);
return value;
}
node = node.getNext();
}
}
return null;//否则返回空
}
public Object replace(Object key,Object newvalue) {
System.out.println(\"replace\");
int code = hashcode(key.toString());//得到哈希码
int position = locate(code);//得到该哈希码所对应的哈希数组中的位置
//找到该位置对应的链表
LinkedList list_head = (LinkedList) array_head.get(position);
//从头遍历链表 ，找到与键key对应的节点的value值进行输出
for(int i=0;i<list_head.size();i++) {
//首先拿到头节点
Node head = (Node) list_head.get(i);
Node node = head;
while(node!=null) {
//如果 键 相等
if(node.getKey().equals(key)) {
Object oldvalue = node.getValue();
node.setValue(newvalue);
return oldvalue;
}
node = node.getNext();
}
}
return null;//否则返回空
}
/**
* @param key
* @return 哈希表中含有该key，返回true
*/
public boolean containsKey(Object key) {
int code = hashcode(key.toString());//得到哈希码
int position = locate(code);//得到该哈希码所对应的哈希数组中的位置
//找到该位置对应的链表
LinkedList list_head = (LinkedList) array_head.get(position);
//从头遍历链表 ，找到与键key对应的节点的value值进行输出
for(int i=0;i<list_head.size();i++) {
//首先拿到头节点
Node head = (Node) list_head.get(i);
Node node = head;
while(node!=null) {
//如果 键 相等
if(node.getKey().equals(key)) {
return true;
}
node = node.getNext();
}
}
return false;//否则返回空
}
public Object containsValue(Object value) {
//找到该位置对应的链表
for(int k=0;k<size;k++) {
LinkedList list_head = (LinkedList) array_head.get(k);
//从头遍历链表 ，找到与键key对应的节点的value值进行输出
for(int i=0;i<list_head.size();i++) {
//首先拿到头节点
Node head = (Node) list_head.get(i);
Node node = head;
while(node!=null) {
//如果 键 相等
if(node.getValue().equals(value)) {
return true;
}
node = node.getNext();
}
}
}
return false;//否则返回空
}
/**
* 打印哈希表
*/
public void show() {
System.out.println(\"打印哈希表\");
for(int i=0;i<size;i++) {
LinkedList list_head = array_head.get(i);//得到链表头
System.out.println(\"链表 ：\"+(i+1));
for(int j=0;j<list_head.size();j++) {
Node head = (Node) list_head.get(j);//取出每个节点
Node node = head;
while(node!=null) {
//打印出每个节点得键值对
System.out.print(\"节点\"+(j+1)+\" :(\"+node.getKey()+\":\"+node.getValue()+\")\"+\"-->\");
node = node.getNext();
}
}
System.out.println();
}
System.out.println();
}
/**
*
* @return 返回存储的节点的个数
*/
public int size() {
return number;
}
/**
* 清除哈希表中的所有元素
*/
public void clear() {
for(int i=0;i<size;i++) {
LinkedList list_head = array_head.get(i);//得到链表头
list_head.clear();
}
number = 0;
}
/**
* 计算字符串的哈希码
* ASCII码相加
* @param s
* @return
*/
public int hashcode(String s) {
int k = 0;
for(int i=0;i<s.length();i++) {
k += s.charAt(i);
}
return k;
}
/**
* 得到哈希码对应在数组中的位置
* @param k
* @return
*/
public int locate(int k) {
int m = k%size;
return m;
}
}
测试代码及结果
public class Test {
public static void main(String[] args) {
MyHash myhash = new MyHash();
myhash.put(\"abc\", 123);
myhash.put(\"b\", 2);
myhash.put(\"c\", 3);
myhash.put(\"a\", 1);
myhash.put(\"d\", 4);
myhash.put(\"e\", 5);
myhash.put(\"f\", 6);
myhash.put(\"g\", 7);
myhash.put(\"h\", 8);
myhash.put(\"i\", 9);
myhash.put(\"j\", 10);
myhash.put(\"k\", 11);
myhash.put(\"l\", 12);
myhash.put(\"m\", 13);
System.out.println(\"myhash.get(\\\"g\\\") :\"+myhash.get(\"g\"));
System.out.println(\"myhash.size() :\"+myhash.size());
System.out.println(\"myhash.replace(\\\"m\\\", 20) :\"+myhash.replace(\"m\", 20));
System.out.println(\"myhash.containsValue(5) :\"+myhash.containsValue(5));
System.out.println(\"myhash.containsKey(\\\"g\\\") :\"+myhash.containsKey(\"g\"));
System.out.println(\"myhash.remove(\\\"j\\\") :\"+myhash.remove(\"j\"));
System.out.println(\"myhash.show()\");
myhash.show();
myhash.clear();
System.out.println(\"myhash.clear()\");
System.out.println(\"myhash.size() :\"+myhash.size());
}
}
更多java相关内容感兴趣的读者可查看本站专题：《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》
希望本文所述对大家java程序设计有所帮助。
