HashMap和Hashtable的区别

加载因子

先来了解个概念：加载因子是表示Hsah表中元素的填满的程度.若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但冲突的机会加大了.反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了.冲突的机会越大,则查找的成本越高.反之,查找的成本越小.因而,查找时间就越小.

简单的说：由于HashMap扩容根据 加载因子*容量 决定,当map中元素个数 > 加载因子*容量时，才会扩容，所以加载因子越大，当然元素存的越多，但是冲突也就越多了。

源码(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值