Java 一个简单Hashtable的实现

如图，是Hashtable采用的链表式的结构，即键值冲突的时候直接加到此键值对应的链表后面。下面提供一个简单的Java类的实现。

1. public class HashTableDef {
3.     private int capacity = 1000;// 非重复的键值个数，即键值从0-999，可以在初始话的时候指定
4.     private Map[] keys;// 存放键值所对应的key-value对
6.     /**
7.      * 默认容量的构造函数，默认容量为1000
8.      */
9.     public HashTableDef() {
10.         keys = new Map[capacity];
11.         for (int i = 0; i < capacity; i++) {
12.             keys[i] = null;
13.         }
14.     }
16.     /**
17.      * 带容量的构造函数
18.      * 
19.      * @param cy
20.      */
21.     public HashTableDef(int cy) {
22.         this.capacity = cy;
23.         keys = new Map[this.capacity];
24.         for (int i = 0; i < capacity; i++) {
25.             keys[i] = null;
26.         }
27.     }
29.     /**
30.      * 把键值对key-value放到hash表中
31.      * 
32.      * @param key
33.      * @param value
34.      */
35.     public void put(Object key, Object value) {
36.         int keyIndex = key.hashCode() % capacity;// 得到此键对应的键值
37.         boolean isSameKey = false;
38.         Map map = new Map();
39.         map.key = key;
40.         map.value = value;
41.         Map currentMap = keys[keyIndex], prevMap = null;
42.         if (currentMap == null) {
43.             // 当前键值没有冲突，
44.             keys[keyIndex] = map;
45.             System.out.println("直接放入到hashtable中" + keys[keyIndex] + " "
46.                     + currentMap);
47.         } else {
48.             // 处理键值冲突，放到此键值对应的链表的最后
49.             while (currentMap != null) {
50.                 // 不光是键值冲突，而且键相等，此时此时覆盖以前的键对应的键值
51.                 if (currentMap.key.equals(key) || currentMap.key == key) {
52.                     currentMap.value = value;
53.                     isSameKey = true;
54.                     System.out.println("出现了同名的Key：" + key);
55.                     break;
56.                 }
57.                 prevMap = currentMap;
58.                 currentMap = currentMap.next;
59.             }
60.             if (isSameKey == false) {
61.                 System.out.println("放到链表中");
62.                 prevMap.next = map;
63.             }
64.         }
66.     }
68.     /**
69.      * 给定键值，取得此键值对应的Value，如果没有，返回null
70.      * 
71.      * @param key
72.      *            键值
73.      * @return
74.      */
75.     public Object get(Object key) {
77.         int keyIndex = key.hashCode() % capacity;// 得到此键对应的键值
78.         Map currentMap = keys[keyIndex];
79.         // 遍历此键值对应的入口链表
80.         while (currentMap != null) {
81.             // 出现相等的键，则返回
82.             if (currentMap.key.equals(key) || currentMap.key == key) {
83.                 return currentMap.value;
84.             }
85.             currentMap = currentMap.next;
86.         }
87.         return null;
88.     }
90.     private class Map {
91.         public Object key;
92.         public Object value;
93.         public Map next = null;
94.     }
95. }