HashMap与HashTable的区别

HashMap与HashTable有什么区别？在面试中经常会问到这样的问题。于是，通过查阅一些资料，总结一下写下这篇博客。

区别1：两者诞生的时间 不同。

 HashTable产生于JDK1.1，而HashMap产生于JDK1.2。从时间上来说，HashMap要比HashTable出现得晚一些。

区别2：类的继承体系不同

可以看一下下面两幅图（HashMap和HashTable的类继承图）

 从上面两幅图中可以看出。HashMap和HashTable都实现了Cloneable、Serializable和Map接口。但是不同之处是

HashMap继承了抽象类AbstractMap，而HashTable继承了抽象类Dictionary(此类已经是一个被废弃的类)

区别3：对于Null key和 Null Value的处理不同

 HashMap支持null键和null值的，而HashTable在遇到null键和null值时会抛出空指针异常。这主要是因为代码中对null值

的处理。可以看一下代码：

以下是HashTable的代码：

public synchronized V put(K key, V value) {

  // 如果value为null，抛出NullPointerException
  if (value == null) {
      throw new NullPointerException();
  }

  // 如果key为null，在调用key.hashCode()时抛出NullPointerException

  // ...
}

以下是HashMap的代码：

public V put(K key, V value) {
  if (table == EMPTY_TABLE) {
      inflateTable(threshold);
  }
  // 当key为null时，调用putForNullKey特殊处理
  if (key == null)
      return putForNullKey(value);
  // ...
}

private V putForNullKey(V value) {
  // key为null时，放到table[0]也就是第0个bucket中
  for (Entry<K,V> e = table[0]; e != null; e = e.next) {
      if (e.key == null) {
          V oldValue = e.value;
          e.value = value;
          e.recordAccess(this);
          return oldValue;
      }
  }
  modCount++;
  addEntry(0, null, value, 0);
  return null;
}

区别4：实现原理方面的不同：主要是在数据结构和算法层面

相同点（数据结构）：HashMap和HashTable都使用哈希表来存储键值对，在数据结构上基本上是相同，都创建了一个继承自

Map.Entry的私有的内部类Entry，每一个Entry对象都表示存储在Hash表中的键值对。

Entry对象唯一表示一个键值对，有四个属性：

-K key 键对象

-V value 值对象

-int hash 键对象的hash值

-Entryentry 指向链表中下一个Entry对象，可为null，表示当前Entry对象在链表尾部

 可以通过下图更加清晰的看出存储的数据结构

这样就可以得出这样的结论：HashMap和HashTable内部用Entry数组实现哈希表，而对于映射到同一个哈希桶

bucket(数组的同意位置)的键值对，使用Entry链表来存储（解决hash冲突）。

算法（不同）：

 上一节中已经说了HashMap和HashTable的内部数据结构。HashMap和HashTable还需要有算法来将一个给定的key值计算出HashCode值，映射到确定的Hash桶（数组位置）需要有算法在hash桶的键值多到一定程度时，扩充hash表的大小（数组的大小）。本节主要是比较两个类在算法层面是有什么样

的不同。

 初始容量大小和每次扩充容量大小的不同。先看一下代码：

以下代码及注释来自java.util.HashTable

// 哈希表默认初始大小为11
public Hashtable() {
  this(11, 0.75f);
}

protected void rehash() {
  int oldCapacity = table.length;
  Entry<K,V>[] oldMap = table;

  // 每次扩容为原来的2n+1
  int newCapacity = (oldCapacity << 1) + 1;
  // ...
}


以下代码及注释来自java.util.HashMap

// 哈希表默认初始大小为2^4=16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

void addEntry(int hash, K key, V value, int bucketIndex) {
  // 每次扩充为原来的2n 
  if ((size >= threshold) && (null != table[bucketIndex])) {
     resize(2 * table.length);
}

从上面的代码中可以看出来，对于HashTable，hash表的默认初始值是11，然后每次扩充为原来的2n+1。

而HashMap的初始值是16，之后每次扩充为原来的2倍。

也就是说HashTable的hash表容量尽量是素数、质数。而HashMap则总是使用2的幂作为hash表的大小。

那它们这样做有什么优缺点那？

当hash表的大小为质数时，简单的取模哈希表的结果会更加的均匀，所以，从这一点上看，HashTable的哈希表大小的选择会

更加的合理。但是另一方面，如果取模数是2的幂的话，我们可以使用另外一种方法会更加的方便：位运算，效率会大大高于

除法运算得到的结果。所以，从Hash计算的效率上，又是HashMap更胜一筹。

所以，hashmap为了解决取模不均匀的问题，又对hash算法做了一些改动。具体我们看看，在获取了key对象的hashCode之后，

HashTable和HashMap分别是怎样将他们哈希到确定的hash桶（Entry数组位置）中的。

以下代码及注释来自java.util.HashTable

// hash 不能超过Integer.MAX_VALUE 所以要取其最小的31个bit
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;

// 直接计算key.hashCode()
private int hash(Object k) {
  // hashSeed will be zero if alternative hashing is disabled.
  return hashSeed ^ k.hashCode();
}


以下代码及注释来自java.util.HashMap
int hash = hash(key);
int i = indexFor(hash, table.length);

// 在计算了key.hashCode()之后，做了一些位运算来减少哈希冲突
final int hash(Object k) {
  int h = hashSeed;
  if (0 != h && k instanceof String) {
      return sun.misc.Hashing.stringHash32((String) k);
  }

  h ^= k.hashCode();

  // This function ensures that hashCodes that differ only by【再哈希算法】
  // constant multiples at each bit position have a bounded
  // number of collisions (approximately 8 at default load factor).
  h ^= (h >>> 20) ^ (h >>> 12);
  return h ^ (h >>> 7) ^ (h >>> 4);
}

// 取模不再需要做除法
static int indexFor(int h, int length) {
  // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
  return h & (length-1);
}

我们可以通过上面的代码可以看出，HashMap由于使用了2的幂次方，所以在位运算取模时，引入了hash冲突加剧的问题。为了解决这个问题，HashMap调用了对象的hashCode()方法之后，又重新做了一些位运算再次打散数据（再hash）。

区别5：线程安全

HashTable是线程同步的，而HashMap不是的。可以看一下代码：

以下代码及注释来自java.util.HashTable

public synchronized V get(Object key) {
  Entry tab[] = table;
  int hash = hash(key);
  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)) {
          return e.value;
      }
  }
  return null;
}

public Set<K> keySet() {
  if (keySet == null)
      keySet = Collections.synchronizedSet(new KeySet(), this);
  return keySet;
}

从代码中我们可以看出来：在公开的方法中，HashTable中的方法都是用了synchronized描述符。