目录
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