一、HashTable类
（一）HashTable类
hashTable将key和value结合起来构成键值对通过put(key,value)方法保存起来，然后通过get(key)方法获取相对应的value值。它是线程安全的哈希映射表，内部采用Entry[]数组，每个Entry均可作为链表的头，用来解决冲突（碰撞）。同时Hashtables提供了一个很有用的方法可以使应用程序的性能达到最佳。
1.1：定义
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable从中可以看出HashTable继承Dictionary类，实现Map接口。其中Dictionary类是任何可将键映射到相应值的类（如 Hashtable）的抽象父类。每个键和每个值都是一个对象。在任何一个 Dictionary 对象中，每个键至多与一个值相关联。Map是"key-value键值对"接口。
1.2：构造函数
// 默认构造函数。
public Hashtable()
// 指定“容量大小”的构造函数
public Hashtable(int initialCapacity)
// 指定“容量大小”和“加载因子”的构造函数
public Hashtable(int initialCapacity, float loadFactor)
// 包含“子Map”的构造函数
public Hashtable(Map<? extends K, ? extends V> t)1.3：重要参数
（1）table：为一个Entry[]数组类型，Entry代表了“拉链”的节点，每一个Entry代表了一个键值对，哈希表的"key-value键值对"都是存储在Entry数组中的。
（2）count：HashTable的大小，注意这个大小并不是HashTable的容器大小，而是他所包含Entry键值对的数量。
（3）threshold：Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值="容量*加载因子"。
（4）loadFactor：加载因子。
（5）modCount：用来实现“fail-fast”机制的（也就是快速失败）。所谓快速失败就是在并发集合中，其进行迭代操作时，若有其他线程对其进行结构性的修改，
这时迭代器会立马感知到，并且立即抛出ConcurrentModificationException异常，而不是等到迭代完成之后才告诉你（你已经出错了）。1.4：方法
synchronized void clear()
synchronized Object clone()
boolean contains(Object value)
synchronized boolean containsKey(Object key)
synchronized boolean containsValue(Object value)
synchronized Enumeration<V> elements()
synchronized Set<Entry<K, V>> entrySet()
synchronized boolean equals(Object object)
synchronized V get(Object key)
synchronized int hashCode()
synchronized boolean isEmpty()
synchronized Set<K> keySet()
synchronized Enumeration<K> keys()
synchronized V put(K key, V value)
synchronized void putAll(Map<? extends K, ? extends V> map)
synchronized V remove(Object key)
synchronized int size()
synchronized String toString()
synchronized Collection<V> values()1.5：源码分析
public class Hashtable<K,V>
{
Entry[] table; // 槽数组，也称桶数组。
int count; // table中实际存放的Entry数量。
int threshold; // 当table数量超过该阈值后，进行reash。（该值为 capacity * loadFactor）
float loadFactor; // 加载因子，默认是0.75f。
public Hashtable(int initialCapacity/*默认是11*/, float loadFactor) {
if(initialCapacity==0) initialCapacity=1;
this.locadFactor = locadFactor;
table = new Entry[initialCapacity];
threshold = (int)(initialCapacity * locadFactor);
}
// put()： 若key存在，返回旧value；若key不存在，返回null。
public synchronized V put(K key,V value) {
// 检查key是否已经存在，若存在则覆盖已经存在value，并返回被覆盖的value。
Entry tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length; // 存储槽位索引。
for(Entry<K,V> e = tab[index]; e!=null; e=e.next ) { // 在冲突链表中寻找
if( (e.hash == hash ) && e.key.equals(key) ) {
V old = e.value;
e.value = value; // 新value覆盖旧value
return old;
}
}
// 是否需要rehash
if(count >= threshold){
rehash();
tab = table; // rehash完毕后，修正tab指针指向新的Entry[]
index = (hash & 0x7FFFFFFF) % tab.length; // 重新计算Slot的index
}
// 存储到槽位，如果有冲突，新来的元素被放到了链表前面。
Entry<K,V> e = tab[index]; // 旧有Entry
tab[index] = new Entry<>(hash,key,value,e/* 旧有Entry成为了新增Entry的next */);
count ++;
return null;
}
// rehash(): 再次hash。当Entry[]的实际存储数量占分配容量的约75%时，扩容并且重新计算各个对象的槽位
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 ;
protected void rehash() {
int oldCapacity = table.length;
Entry[] oldMap = table;
int newCapacity = (oldCapacity << 1) + 1; // 2倍+1
Entry[] newMap = new Entry[newCapacity];
threshold = (int)(newCapacity * loadFactor);
table = newMap;
for( int i=oldCapacity; i-- >0;){ // i的取值范围为 [oldCapacity-1,0]
for (Entry<K,V> old = oldMap[i]; old!=null;){ // 遍历旧Entry[]
Entry<K,V> e = old;
int index = (e.hash & 0x7FFFFFFF) % newCapacity; // 重新计算各个元素在新Entry[]中的槽位index。
e.next = newMap[index]; // 已经存在槽位中的Entry放到当前元素的next中
newMap[index]=e; // 放到槽位中
old = old.next;
}
}
}
}1.6：操作例子
public class HashtableTest {
public static void main(String[] args) {
testHashtableAPIs();
}
private static void testHashtableAPIs() {
// 初始化随机种子
Random r = new Random();
// 新建Hashtable
Hashtable table = new Hashtable();
// 添加操作
table.put("one", r.nextInt(10));
table.put("two", r.nextInt(10));
table.put("three", r.nextInt(10));
// 打印出table
System.out.println("table:"+table );
// 通过Iterator遍历key-value
Iterator iter = table.entrySet().iterator();
while(iter.hasNext()) {
Map.Entry entry = (Map.Entry)iter.next();
System.out.println("next : "+ entry.getKey() +" - "+entry.getValue());
}
// Hashtable的键值对个数
System.out.println("size:"+table.size());
// containsKey(Object key) :是否包含键key
System.out.println("contains key two : "+table.containsKey("two"));
System.out.println("contains key five : "+table.containsKey("five"));
// containsValue(Object value) :是否包含值value
System.out.println("contains value 0 : "+table.containsValue(new Integer(0)));
// remove(Object key) ： 删除键key对应的键值对
table.remove("three");
System.out.println("table:"+table );
// clear() ： 清空Hashtable
table.clear();
// isEmpty() : Hashtable是否为空
System.out.println((table.isEmpty()?"table is empty":"table is not empty") );
}
}运行结果:
table:{two=5, one=0, three=6}
next : two - 5
next : one - 0
next : three - 6
size:3
contains key two : true
contains key five : false
contains value 0 : true
table:{two=5, one=0}
table is empty1.7：HashTable与HashMap的区别
HashTable和HashMap存在很多的相同点，但是他们还是有几个比较重要的不同点。
第一：我们从他们的定义就可以看出他们的不同，HashTable基于Dictionary类，而HashMap是基于AbstractMap。Dictionary是什么？它是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的骨干实现，它以最大限度地减少实现此接口所需的工作。
第二：HashMap可以允许存在一个为null的key和任意个为null的value，但是HashTable中的key和value都不允许为null。当HashMap遇到为null的key时，它会调用putForNullKey方法来进行处理。对于value没有进行任何处理，只要是对象都可以。
if (key == null) {
return putForNullKey(value);
}而当HashTable遇到null时，他会直接抛出NullPointerException异常信息。
if (value == null) {
throw new NullPointerException();
}第三：Hashtable的方法是同步的，而HashMap的方法不是。所以有人一般都建议如果是涉及到多线程同步时采用HashTable，没有涉及就采用HashMap，但是在Collections类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的Map对象，并把它作为一个封装的对象来返回，所以通过Collections类的synchronizedMap方法是可以我们你同步访问潜在的HashMap。
1.8：总结
1. 线程安全。
2. Key、Value均不能为null。
3. 包含了一个Entry[]数组，而Entry又是一个链表，用来处理冲突。
4. 每个Key对应了Entry数组中固定的位置（记为index），称为槽位（Slot）。槽位计算公式为： (key.hashCode() & 0x7FFFFFFF) % Entry[].length() 。
5. 当Entry[]的实际元素数量（Count）超过了分配容量（Capacity）的75%时，新建一个Entry[]是原先的2倍，并重新Hash（rehash）。
6. rehash的核心思路是，将旧Entry[]数组的元素重新计算槽位，散列到新Entry[]中。
（二）HashTable遍历方法（2种）
2.1：for循环遍历
Hashtable<String, String> ht = new Hashtable<String, String>();
ht.put("one", "The first");
ht.put("two", "The second");
ht.put("three", "The third");
Set<String> s = ht.keySet();
for(String ss:s){
System.out.println("Current hashtable element is: " + ss);
}2.2：Enumeration对象遍历
Person person1=new Person("zhangsan",20);
Person person2=new Person("lisi",21);
Person person3=new Person("wangwu",22);
Hashtable ht = new Hashtable();//不能Map ht=new Hashtable();若加强制转换后，后面方法不能用
ht.put("first", person1);
ht.put("second", person2);
ht.put("three", person3);
Enumeration e=ht.elements();
while(e.hasMoreElements()){
Person person=(Person)e.nextElement();
System.out.println(person.getName()+" "+person.getAge());
}（三）HashTable排序方法（2种）
3.1：用ArrayList的sort排序功能
Hashtable ht = new Hashtable();
ht.Add("dd", "value2");
ht.Add("cc", "value3");
ht.Add("bb", "value4");
ht.Add("aa", "value5");
ArrayList list = new ArrayList(ht.Keys);
list.Sort();
foreach (string str in list)
{ Console.WriteLine(str+":"+ht[str]);
}运行结果
aa:value5
bb:value4
cc:value3
dd:value2上面例子按照key的每一个字符的ASCII的值就行排序的。从左到右比较每个字符的Ascii的值，直到满足两个字符的ASCII的值不同即停止比较。
3.2：用Collections.sort自定义排序
Hashtable<String, String> h = new Hashtable<String, String>();
h.put("6", "666");
h.put("8", "888");
h.put("2", "222");
<br>for (String key : h.keySet())
System.out.println(key);
System.out.println("----------------------------------------------------------");
List<String> v = new ArrayList<String>(h.keySet());
Collections.sort(v, new Comparator<Object>() {
public int compare(Object arg0, Object arg1) {
return Integer.valueOf(arg0.toString()) - Integer.valueOf(arg1.toString()); // 升序，参数顺序对调时降序<br> }
});
for (String key : v)
System.out.println(key + " " + h.get(key));
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
