加载因子
先来了解个概念:加载因子是表示Hsah表中元素的填满的程度.若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但冲突的机会加大了.反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了. 冲突的机会越大,则查找的成本越高.反之,查找的成本越小.因而,查找时间就越小.
简单的说:由于HashMap扩容根据 加载因子*容量 决定,当map中元素个数 > 加载因子*容量时,才会扩容,所以加载因子越大,当然元素存的越多,但是冲突也就越多了。
HashMap的扩容:
Hashtable的部分构造函数与成员变量:
Hashtable的扩容:
源码(JDK1.8)简单分析:
HashMap的部分构造函数与成员变量:public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//默认初始容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//默认最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//当实际数据大小超过threshold时,HashMap会将容量扩容,threshold=容量*加载因子
int threshold;
//加载因子
final float loadFactor;
public HashMap(int initialCapacity, float loadFactor) {//传入默认初始大小和加载因子
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
public HashMap(int initialCapacity) {//传入默认初始容量大小
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {//无参构造
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
}
HashMap的扩容:
//重新设置table大小
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {//当表不为空时
if (oldCap >= MAXIMUM_CAPACITY) {//判断是否到达最大容量
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)//旧容量进行扩容一倍
newThr = oldThr << 1; // threshold也进行1倍扩容
}
else if (oldThr > 0) // 表为空,threshold不为空情况 initial capacity was placed in threshold
newCap = oldThr;
else {//都为空情况使用默认 // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY; //16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //12
}
if (newThr == 0) {//针对上面的第二种情况
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;//对threshold进行重新赋值
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//创建新的哈希表
table = newTab;//将新的地址赋值给table
if (oldTab != null) {//如果旧表不为空,将对其复制到新表中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)//表中只有一个Entry情况
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)//TreeNode没研究
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order//有多个Entry,即有链
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
Hashtable的部分构造函数与成员变量:
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable {
//当实际数据大小超过threshold时,进行扩容,threshold=容量*加载因子
private int threshold;
//加载因子
private float 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);
}
public Hashtable(int initialCapacity) {//传入初始容量大小的构造,加载因子为0.75
this(initialCapacity, 0.75f);
}
public Hashtable() {//无参构造,默认初始容量为11,加载因子为0.75
this(11, 0.75f);
}
}
Hashtable的扩容:
protected void rehash() {
int oldCapacity = table.length;
Entry<?,?>[] oldMap = table;
// overflow-conscious code
int newCapacity = (oldCapacity << 1) + 1; //扩容的大小为原来的两倍 + 1
if (newCapacity - MAX_ARRAY_SIZE > 0) {//判断是否超过最大size
if (oldCapacity == MAX_ARRAY_SIZE)
// Keep running with MAX_ARRAY_SIZE buckets
return;
newCapacity = MAX_ARRAY_SIZE;
}
Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
modCount++;
threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);//重新计算 threshold
table = newMap;
//将旧表中数据copy到新表中
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = (Entry<K,V>)newMap[index];
newMap[index] = e;
}
}
}
Hashtable和HashMap的比较
以下表格内容参考自:http://www.cnblogs.com/carbs/archive/2012/07/04/2576995.html
|
Hashtable
|
HashMap
|
并发操作
|
使用同步机制,
实际应用程序中,仅仅是Hashtable本身的同步并不能保证程序在并发操作下的正确性,需要高层次的并发保护。
下面的代码试图在key所对应的value值等于x的情况下修改value为x+1
{
value = hashTable.get(key);
if(value.intValue()== x){
hashTable.put(key, new Integer(value.intValue()+1));
}
}
如2个线程同时执行以上代码,可能放入不是x+1,而是x+2.
|
没有同步机制,需要使用者自己进行并发访问控制
|
数据遍历的方式
|
Iterator 和 Enumeration
|
Iterator
|
是否支持fast-fail
|
用Iterator遍历,支持fast-fail
用Enumeration不支持fast-fail.
|
支持fast-fail
|
是否接受值为null的Key 或Value?
|
不接受
|
接受
|
根据hash值计算数组下标的算法
|
当数组长度较小,并且Key的hash值低位数值分散不均匀时,不同的hash值计算得到相同下标值的几率较高
hash = key.hashCode();
index=(hash&0x7FFFFFFF) % tab.length;
|
优于hashtable,通过对Key的hash做移位运算和位的与运算,使其能更广泛地分散到数组的不同位置
hash = hash (k);
index = indexFor(hash, table.length);
static int hash(Object x) {
int h = x.hashCode();
h += ~(h << 9);
h ^= (h >>> 14);
h += (h << 4);
h ^= (h >>> 10);
return h;
}
static int indexFor(int h, int length) {
return h & (length-1);
}
|
Entry数组的长度
|
Ø
缺省初始长度为11,
Ø
初始化时可以指定initial capacity
|
Ø
缺省初始长度为16,
Ø
长度始终保持2的n次方
Ø
初始化时可以指定initial capacity,若不是2的次方,HashMap将选取第一个大于initial capacity 的2n次方值作为其初始长度
|
LoadFactor负荷因子
|
0.75
| |
负荷超过(loadFactor * 数组长度)时,内部数据的调整方式
|
扩展数组:2*原数组长度+1
|
扩展数组: 原数组长度 * 2
|
两者都会重新根据Key的hash值计算其在数组中的新位置,重新放置。算法相似,时间、空间效率相同
|
一般情况下,HashMap能够比Hashtable工作的更好、更快,主要得益于它的散列算法,以及没有同步。应用程序一般在更高的层面上实 现了保护机制,而不是依赖于这些底层数据结构的同步,因此,HashMap能够在大多应用中满足需要。推荐使用HashMap,如果需要同步,可以使用同 步工具类将其转换成支持同步的HashMap。
主要总结
1.Hashtable是JDK1.0版本出现的,是线程安全的,效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率高
2.Hashtable不可以存储null键和null值,HashMap可以存储null键和null值