HashTable1.8源码解读
目录1，哈希表的简介1.1，HashTable的构造函数1.2，HashTable的属性说明1.3，HashTable的PAI2，HashTable的数据结构2.1，HashTable的内部类2.2，HashTable中重要方法分析2.2.1，put()方法2.2.2，addEntry()方法2.2.3，rehash()方法2.2.4，get()方法2.2.5，remove()删除元素方法2.3，
·
目录
2.3.2，contains() 和 containsValue()
2.5，Hashtable实现的Serializable接口
3.4，通过Enumeration遍历Hashtable的键
3.5，通过Enumeration遍历Hashtable的值
1，哈希表的简介
- 和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。
- Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。
- Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。此外，Hashtable中的映射不是有序的。
- Hashtable 的实例有两个参数影响其性能：初始容量 和 加载因子。容量 是哈希表中桶 的数量，初始容量 就是哈希表创建时的容量。注意，哈希表的状态为 open：在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索。加载因子 是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示。关于何时以及是否调用 rehash 方法的具体细节则依赖于该实现。
- 通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查找某个条目的时间（在大多数 Hashtable 操作中，包括 get 和 put 操作，都反映了这一点）。
- Hashtable 和 HashMap 的底层是以数组来存储，同时，在存储数据通过
key计算数组下标的时候，是以哈希算法为主，因此可能会产生哈希冲突的可能性，通俗的说呢，就是不同的key，在计算的时候，可能会产生相同的数组下标，这个时候，如何将两个对象放入一个数组中呢？而解决哈希冲突的办法，有两种，一种开放地址方式（当发生 hash 冲突时，就继续以此继续寻找，直到找到没有冲突的hash值），另一种是拉链方式（将冲突的元素放入链表），HashTable使用的就是拉链法解决冲突问题的。当发生不同的key通过一系列的哈希算法计算获取到相同的数组下标的时候，会将对象放入一个数组容器中，然后将对象以单向链表的形式存储在同一个数组下标容器中，就像链子一样，挂在某个节点上，如下图：
1.1，HashTable的构造函数
//带参数的哈希表构造函数
//initialCapacity:哈希表的初始容量
//loadFactor：哈希表的加载因子
public Hashtable(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal Load: "+loadFactor);
//判断初始容量设置是否合理
if (initialCapacity==0)
initialCapacity = 1;
//初始化加载因子
this.loadFactor = loadFactor;
//开辟哈希表数组的存储空间
table = new Entry<?,?>[initialCapacity];
//初始化阈值的设置
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}
//initialCapacity：哈希表的初始容量
public Hashtable(int initialCapacity) {
//初始化默认加载因子是0.75
this(initialCapacity, 0.75f);
}
//无参构造函数，默认数组大小是11，加载因子是0.75
public Hashtable() {
this(11, 0.75f);
}
//构造一个和Map类型一样的哈希表，然后把一个map中的元素添加到哈希表中
public Hashtable(Map<? extends K, ? extends V> t) {
this(Math.max(2*t.size(), 11), 0.75f);
putAll(t);
}1.2，HashTable的属性说明
//哈希表数组，里面存储的是键值对，Entry继承与Map.Entry
private transient Entry<?,?>[] table;
//哈希表中元素的个数
private transient int count;
//哈希表扩容的阈值，计算方法是capacity * loadFactor
private int threshold;
//哈希表的加载因子
private float loadFactor;
// 表示记录 Hashtable 修改的次数，用来实现快速失败抛异常处理；
private transient int modCount = 0;
//序列号
private static final long serialVersionUID = 1421746759512286392L;1.3，HashTable的PAI
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()2，HashTable的数据结构
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable {}
- jdk1.8底层HashTable使用的数据结构是：数组+链表。
- Hashtable继承于Dictionary类，实现了Map接口。Map是"key-value键值对"接口，Dictionary是声明了操作"键值对"函数接口的抽象类。
- 其中 Dictionary 类是一个已经被废弃的类，这个类已经过时，新的实现应该实现 Map 接口而不是扩展此类，
- Hashtable是通过"拉链法"实现的哈希表，也就是解决冲突使用的是拉链法。
2.1，HashTable的内部类
- KeySet类，这个类用来获取哈希表的键值集合时使用
private class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return getIterator(KEYS);
}
public int size() {
return count;
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
return Hashtable.this.remove(o) != null;
}
public void clear() {
Hashtable.this.clear();
}
}- EntrySet类，通过entry键值对遍历哈希表的时候使用。
private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return getIterator(ENTRIES);
}
public boolean add(Map.Entry<K,V> o) {
return super.add(o);
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> entry = (Map.Entry<?,?>)o;
Object key = entry.getKey();
Entry<?,?>[] tab = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index]; e != null; e = e.next)
if (e.hash==hash && e.equals(entry))
return true;
return false;
}
public boolean remove(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
Object key = entry.getKey();
Entry<?,?>[] tab = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>)tab[index];
for(Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
if (e.hash==hash && e.equals(entry)) {
modCount++;
if (prev != null)
prev.next = e.next;
else
tab[index] = e.next;
count--;
e.value = null;
return true;
}
}
return false;
}
public int size() {
return count;
}
public void clear() {
Hashtable.this.clear();
}
}- ValueCollection类，通过值遍历哈希表的时候使用。
private class ValueCollection extends AbstractCollection<V> {
public Iterator<V> iterator() {
return getIterator(VALUES);
}
public int size() {
return count;
}
public boolean contains(Object o) {
return containsValue(o);
}
public void clear() {
Hashtable.this.clear();
}
}- 哈希表中的节点类型，是键值对类型，继承于Map中Entry的接口。
private static class Entry<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Entry<K,V> next;
protected Entry(int hash, K key, V value, Entry<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
@SuppressWarnings("unchecked")
protected Object clone() {
return new Entry<>(hash, key, value,
(next==null ? null : (Entry<K,V>) next.clone()));
}
// Map.Entry Ops
public K getKey() {
return key;
}
public V getValue() {
return value;
}
public V setValue(V value) {
if (value == null)
throw new NullPointerException();
V oldValue = this.value;
this.value = value;
return oldValue;
}
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
(value==null ? e.getValue()==null : value.equals(e.getValue()));
}
public int hashCode() {
return hash ^ Objects.hashCode(value);
}
public String toString() {
return key.toString()+"="+value.toString();
}
}
2.2，HashTable中重要方法分析
2.2.1，put()方法
- put()方法是向哈希表中插入一个元素，这里插入一个元素和HashMap中是一样的，都是头插法。
- put()方法的逻辑：
-
先获取
synchronized锁。 -
put()方法不允许哈希表的值为null,如果为null的话就抛出异常。
-
计算key对应的哈希码和index值。
-
遍历哈希表中的index位置链表，如果发现有相同的对象，就更新元素的value值，返回旧的值，否则调用addEntry()做插入操作。
-
addEntry()方法中，如果需要扩容，会先进行扩容操作，然后采用头插法插入元素。
-
- 下面图是HashMap 的put()方法过程，hableTable的put()方法的逻辑基本和HashMap的一致，差别在于哈希表中没有使用到红黑树。
//向哈希表中插入一个元素
//key:entry的键值
//values:entry的值
//需要注意的是HashTable中的键和值都不可以是空的，也就是NULL值
public synchronized V put(K key, V value) {
// 判断值是否是空
if (value == null) {
throw new NullPointerException();
}
// 使用一个引用指向哈希表中的表
Entry<?,?> tab[] = table;
//获取键值的哈希码
int hash = key.hashCode();
//获取键值存储在数组中的数组下标
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
//获取第index个元素的第一个元素
Entry<K,V> entry = (Entry<K,V>)tab[index];
//循环遍历第index个链表，寻找插入位置
for(; entry != null ; entry = entry.next) {
//判断是否有重复的元素，如果有的话就做更新操作，然后把旧的元素值返回
if ((entry.hash == hash) && entry.key.equals(key)) {
V old = entry.value;
entry.value = value;
return old;
}
}
//添加一个节点
addEntry(hash, key, value, index);
return null;
}2.2.2，addEntry()方法
- 插入一个元素的逻辑：
- 先判断是否需要对哈希表进行扩容，如果需要进行扩容，就使用rehash()进行扩容操作。
- 记录第index位置处的元素。
- 创建一个新的节点并且插入第index位置处链表的头结点，这里采用的是头插法。
//hash:key对应的哈希码
//key:待插入元素的key
//value:待插入元素的value
//index:插入位置的索引
private void addEntry(int hash, K key, V value, int index) {
modCount++;
Entry<?,?> tab[] = table;
//判断是否需要进行扩容操作
if (count >= threshold) {
rehash();
tab = table;
hash = key.hashCode();
index = (hash & 0x7FFFFFFF) % tab.length;
}
//获取哈希表中第index位置处的元素
@SuppressWarnings("unchecked")
Entry<K,V> e = (Entry<K,V>) tab[index];
//创建一个新节点并且插入头部
tab[index] = new Entry<>(hash, key, value, e);
count++;
}2.2.3，rehash()方法
- 扩容方法逻辑：这里的元素的转义和HashMap里面的逻辑一样。
- 先使得新的数组容量为老数组容量的2倍+1.
- 判断新的数组容量是否超过最大的容量值。
- 重新设置阈值。
- 把老数组中的元素重新计算索引然后插入到新的数组里面。
protected void rehash() {
//记录老数组的长度
int oldCapacity = table.length;
//创建一个引用指向老数组
Entry<?,?>[] oldMap = table;
// 新数组的容量是老数组容量的2倍+1
int newCapacity = (oldCapacity << 1) + 1;
//判断新数组容量是否超过 哈希表设置的最大值
if (newCapacity - MAX_ARRAY_SIZE > 0) {
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
newCapacity = MAX_ARRAY_SIZE;
}
//创建一个哈希表，使用新的容量newCapacity
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
modCount++;
//重新设置哈希表的阈值
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
//哈希表重新指向新数组的引用
table = newMap;
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
//e指向第oldMap[i]链表的第一个元素
Entry<K,V> e = old;
//old指向e的下一个元素
old = old.next;
//重新计算元素e在新数组中的存储位置，也就是下标
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
//把元素e插入新数组的头部，此时e的next指向新数组中第index位置后面的所有元素
e.next = (Entry<K,V>)newMap[index];
//设置第index条链表的新的链表头部
newMap[index] = e;
}
}
}2.2.4，get()方法
- get()方法的逻辑：
- 先获取synchronized()锁。
- 计算对象的哈希码和index值。
- 在对应的链表中查找对应的元素值并且返回。
- 如果遍历结束没有找到就返回null。
- 同样，有一个值得注意的地方是 get 方法加了
synchronized关键字，所以，在同步操作的时候，是线程安全的。
//获取哈希表中的某一个元素
@SuppressWarnings("unchecked")
public synchronized V get(Object key) {
Entry<?,?> tab[] = table;
//获取元素key的哈希码
int hash = key.hashCode();
//计算元素在数组中的下标
int index = (hash & 0x7FFFFFFF) % tab.length;
//遍历第index条链表，如果查找到就返回，否则返回null值
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return (V)e.value;
}
}
return null;
}2.2.5，remove()删除元素方法
- 删除元素的逻辑：
- 先获取synchronized()锁。
- 计算对象的哈希码和Index。
- 遍历第index条链表，如果找到待删除的元素，就删除，返回元素值。
- 如果没有找到待删除的元素，就返回null值。
- 同样，有一个值得注意的地方是 remove 方法加了
synchronized关键字，所以，在同步操作的时候，是线程安全的。
public synchronized V remove(Object key) {
Entry<?,?> tab[] = table;
//计算元素的哈希码
int hash = key.hashCode();
//获取元素的素索引
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
//获取哈希表中第index位置处的元素
Entry<K,V> e = (Entry<K,V>)tab[index];
//因为在链表中删除元素需要找到其前驱结点，所以使用了一个引用prev
for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {
//如果找到删除的元素
if ((e.hash == hash) && e.key.equals(key)) {
modCount++;
if (prev != null) {
//删除节点e，链表中节点不止一个的情况
prev.next = e.next;
} else {
//也就是链表中只有一个节点的情况
tab[index] = e.next;
}
//删除后返回删除元素的值
count--;
V oldValue = e.value;
e.value = null;
return oldValue;
}
}
//没有找到删除的元素就返回Null
return null;
}
2.3，哈希别中其他方法说明
2.3.1，clear()方法
clear() 的作用是清空Hashtable。它是将Hashtable的table数组的值全部设为null
public synchronized void clear() {
Entry<?,?> tab[] = table;
modCount++;
for (int index = tab.length; --index >= 0; )
tab[index] = null;
count = 0;
}2.3.2，contains() 和 containsValue()
contains() 和 containsValue() 的作用都是判断Hashtable是否包含“值(value)”
public boolean containsValue(Object value) {
return contains(value);
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> entry = (Map.Entry<?,?>)o;
Object key = entry.getKey();
Entry<?,?>[] tab = table;
//计算哈希码
int hash = key.hashCode();
//计算下标
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index]; e != null; e = e.next)
if (e.hash==hash && e.equals(entry))
return true;
return false;
}2.3.3，containsKey()
containsKey() 的作用是判断Hashtable是否包含key
public synchronized boolean containsKey(Object key) {
Entry<?,?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return true;
}
}
return false;
}
2.3.4，putAll()
putAll() 的作用是将“Map(t)”的中全部元素逐一添加到Hashtable中
public synchronized void putAll(Map<? extends K, ? extends V> t) {
for (Map.Entry<? extends K, ? extends V> e : t.entrySet())
put(e.getKey(), e.getValue());
}2.4，Hashtable实现的Cloneable接口
public synchronized Object clone() {
try {
Hashtable<?,?> t = (Hashtable<?,?>)super.clone();
t.table = new Entry<?,?>[table.length];
for (int i = table.length ; i-- > 0 ; ) {
t.table[i] = (table[i] != null)
? (Entry<?,?>) table[i].clone() : null;
}
t.keySet = null;
t.entrySet = null;
t.values = null;
t.modCount = 0;
return t;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}2.5，Hashtable实现的Serializable接口
Hashtable实现java.io.Serializable，分别实现了串行读取、写入功能。
串行写入函数就是将Hashtable的“总的容量，实际容量，所有的Entry”都写入到输出流中
串行读取函数：根据写入方式读出将Hashtable的“总的容量，实际容量，所有的Entry”依次读出
private void writeObject(java.io.ObjectOutputStream s)
throws IOException {
Entry<Object, Object> entryStack = null;
synchronized (this) {
// Write out the threshold and loadFactor
s.defaultWriteObject();
// Write out the length and count of elements
s.writeInt(table.length);
s.writeInt(count);
// Stack copies of the entries in the table
for (int index = 0; index < table.length; index++) {
Entry<?,?> entry = table[index];
while (entry != null) {
entryStack =
new Entry<>(0, entry.key, entry.value, entryStack);
entry = entry.next;
}
}
}
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{
// Read in the threshold and loadFactor
s.defaultReadObject();
// Validate loadFactor (ignore threshold - it will be re-computed)
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new StreamCorruptedException("Illegal Load: " + loadFactor);
// Read the original length of the array and number of elements
int origlength = s.readInt();
int elements = s.readInt();
// Validate # of elements
if (elements < 0)
throw new StreamCorruptedException("Illegal # of Elements: " + elements);
// Clamp original length to be more than elements / loadFactor
// (this is the invariant enforced with auto-growth)
origlength = Math.max(origlength, (int)(elements / loadFactor) + 1);
// Compute new length with a bit of room 5% + 3 to grow but
// no larger than the clamped original length. Make the length
// odd if it's large enough, this helps distribute the entries.
// Guard against the length ending up zero, that's not valid.
int length = (int)((elements + elements / 20) / loadFactor) + 3;
if (length > elements && (length & 1) == 0)
length--;
length = Math.min(length, origlength);
table = new Entry<?,?>[length];
threshold = (int)Math.min(length * loadFactor, MAX_ARRAY_SIZE + 1);
count = 0;
// Read the number of elements and then all the key/value objects
for (; elements > 0; elements--) {
@SuppressWarnings("unchecked")
K key = (K)s.readObject();
@SuppressWarnings("unchecked")
V value = (V)s.readObject();
// sync is eliminated for performance
reconstitutionPut(table, key, value);
}
}
3，HashTable的遍历
3.1，通过Entry键值对进行遍历操作
- 第一步：根据entrySet()获取Hashtable的“键值对”的Set集合。
- 第二步：通过Iterator迭代器遍历“第一步”得到的集合。
public class TestHashTable {
public static void main(String[] args) {
// hashtable的创建
Hashtable <Integer,String>hashtable=new Hashtable<Integer,String>();
hashtable.put(1,"aaa");
hashtable.put(2,"bbb");
hashtable.put(3,"ccc");
hashtable.put(4,"ddd");
hashtable.put(5,"eee");
// 获取entry的键值对集合
Set entry=hashtable.entrySet();
//通过迭代器进行遍历entry
Iterator iterator=entry.iterator();
while (iterator.hasNext()){
Map.Entry entry1=(Map.Entry)iterator.next();
System.out.println(entry1.getKey()+" "+entry1.getValue());
}
}
}3.2，通过哈希表的key进行遍历
- 第一步：根据keySet()获取Hashtable的“键”的Set集合。
- 第二步：通过Iterator迭代器遍历“第一步”得到的集合。
public class TestHashTable {
public static void main(String[] args) {
// hashtable的创建
Hashtable <Integer,String>hashtable=new Hashtable<Integer,String>();
hashtable.put(1,"aaa");
hashtable.put(2,"bbb");
hashtable.put(3,"ccc");
hashtable.put(4,"ddd");
hashtable.put(5,"eee");
//返回哈希表key的集合
Set keyS=hashtable.keySet();
// 获取迭代器
Iterator iterator=keyS.iterator();
while (iterator.hasNext()){
Integer integer=(Integer)iterator.next();
System.out.println(hashtable.get(integer));
}
}
}
3.3，通过Values集合遍历
- 第一步：根据value()获取Hashtable的“值”的集合。
- 第二步：通过Iterator迭代器遍历“第一步”得到的集合。
public class TestHashTable {
public static void main(String[] args) {
// hashtable的创建
Hashtable <Integer,String>hashtable=new Hashtable<Integer,String>();
hashtable.put(1,"aaa");
hashtable.put(2,"bbb");
hashtable.put(3,"ccc");
hashtable.put(4,"ddd");
hashtable.put(5,"eee");
//获取值的集合
Collection collections= hashtable.values();
Iterator iterator=collections.iterator();
while (iterator.hasNext()){
String str=(String)iterator.next();
System.out.println(str);
}
3.4，通过Enumeration遍历Hashtable的键
- 第一步：根据keys()获取Hashtable的集合。
- 第二步：通过Enumeration遍历“第一步”得到的集合。
public class TestHashTable {
public static void main(String[] args) {
// hashtable的创建
Hashtable <Integer,String>hashtable=new Hashtable<Integer,String>();
hashtable.put(1,"aaa");
hashtable.put(2,"bbb");
hashtable.put(3,"ccc");
hashtable.put(4,"ddd");
hashtable.put(5,"eee");
Enumeration enu=hashtable.keys();
while (enu.hasMoreElements()){
System.out.println(enu.nextElement());
}
}
}3.5，通过Enumeration遍历Hashtable的值
- 第一步：根据elements()获取Hashtable的集合。
- 第二步：通过Enumeration遍历“第一步”得到的集合。
public class TestHashTable {
public static void main(String[] args) {
// hashtable的创建
Hashtable <Integer,String>hashtable=new Hashtable<Integer,String>();
hashtable.put(1,"aaa");
hashtable.put(2,"bbb");
hashtable.put(3,"ccc");
hashtable.put(4,"ddd");
hashtable.put(5,"eee");
Enumeration enumeration=hashtable.elements();
while (enumeration.hasMoreElements()){
System.out.println(enumeration.nextElement());
}
}
}
4，小结
- HashTable和HashMap的区别：
- HashMap是非线程安全的，而HashTable是线程安全的，所以说HashTabel更加重量级一些，因为需要使用synchronized来保证线程安全。
- HashMap允许key和value的值都为Null（允许一个为null的key和多个为null的value），但是HashTable不允许键和值都是空。
- HashTable继承自jdk 1.0的Dictionary的虚拟类，但是HashMap是jdk 1.2引入的Map接口的实现。
- HashTable和HashMap的扩容机制是不一样的，HashTable的默认容量大小是11，但是扩容后大小是:old*2+1，也就是使得数组的长度尽量是一个素数，这样的话可以使元素的哈希表中分配的更加均匀，,但是HashMap的默认容量是16，一定是2的指数幂，以后每一次的扩容大小都是原来数组容量的2倍，两者的默认填充因子都是0.75，也就是说 HashTable 会尽量使用素数、奇数来做数组的容量，而 HashMap 则总是使用 2 的幂作为数组的容量，但是在运算速度上，HashMap更加有优势，因为使用的是移位运算。
- 两者通过hash函数取index的算法不一样，HashTable使用的是除留余数法，直接使用的是Object的HashCode()方法对哈希表数组长度取余得到的，即（int hash = key.hashCode();int index = (hash & 0x7FFFFFFF) % tab.length;），，而HashMap是强制容量为2的幂，根据HashCode()函数获取哈希值后重新使用hash()方法计算index，使用的方法是hash和（哈希表长度-1）做与运算计算Index，这样计算得到的index更加分散，保证获取额index可以更加均匀的分配到数组中的各个位置，但是HashTable使用的方法就不一定能够保证。
参考资料：
[1] https://www.imooc.com/article/details/id/23015
[2] https://blog.51cto.com/10414498/1846953
CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！
更多推荐
0
0- 0
已为社区贡献1条内容
所有评论(0)