HashTable和HashMap的区别详解

时间  2019-11-11
标签 hashtable hashmap 区别 详解 栏目 Java 繁體版
原文   原文链接
 

1、HashMap简介

      HashMap是基于哈希表实现的，每个元素是一个key-value对，其内部经过单链表解决冲突问题，容量不足（超过了阀值）时，一样会自动增加。html

      HashMap是非线程安全的，只是用于单线程环境下，多线程环境下能够采用concurrent并发包下的concurrentHashMap。java

      HashMap 实现了Serializable接口，所以它支持序列化，实现了Cloneable接口，能被克隆。数组

      HashMap存数据的过程是：安全

      HashMap内部维护了一个存储数据的Entry数组，HashMap采用链表解决冲突，每个Entry本质上是一个单向链表。当准备添加一个key-value对时，首先经过hash(key)方法计算hash值，而后经过indexFor(hash,length)求该key-value对的存储位置，计算方法是先用hash&0x7FFFFFFF后，再对length取模，这就保证每个key-value对都能存入HashMap中，当计算出的位置相同时，因为存入位置是一个链表，则把这个key-value对插入链表头。多线程

      HashMap中key和value都容许为null。key为null的键值对永远都放在以table[0]为头结点的链表中。并发

      了解了数据的存储，那么数据的读取也就很容易就明白了。app

      HashMap的存储结构，以下图所示：函数

 

      图中，紫色部分即表明哈希表，也称为哈希数组，数组的每一个元素都是一个单链表的头节点，链表是用来解决冲突的，若是不一样的key映射到了数组的同一位置处，就将其放入单链表中。oop

      HashMap内存储数据的Entry数组默认是16，若是没有对Entry扩容机制的话，当存储的数据一多，Entry内部的链表会很长，这就失去了HashMap的存储意义了。因此HasnMap内部有本身的扩容机制。HashMap内部有：post

      变量size，它记录HashMap的底层数组中已用槽的数量；

      变量threshold，它是HashMap的阈值，用于判断是否须要调整HashMap的容量（threshold = 容量*加载因子）    

      变量DEFAULT_LOAD_FACTOR = 0.75f，默认加载因子为0.75

      HashMap扩容的条件是：当size大于threshold时，对HashMap进行扩容  

      扩容是是新建了一个HashMap的底层数组，然后调用transfer方法，将就HashMap的所有元素添加到新的HashMap中（要从新计算元素在新的数组中的索引位置）。 很明显，扩容是一个至关耗时的操做，由于它须要从新计算这些元素在新的数组中的位置并进行复制处理。所以，咱们在用HashMap的时，最好能提早预估下HashMap中元素的个数，这样有助于提升HashMap的性能。

      HashMap共有四个构造方法。构造方法中提到了两个很重要的参数：初始容量和加载因子。这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中槽的数量（即哈希数组的长度），初始容量是建立哈希表时的容量（从构造函数中能够看出，若是不指明，则默认为16），加载因子是哈希表在其容量自动增长以前能够达到多满的一种尺度，当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 resize 操做（即扩容）。

      下面说下加载因子，若是加载因子越大，对空间的利用更充分，可是查找效率会下降（链表长度会愈来愈长）；若是加载因子过小，那么表中的数据将过于稀疏（不少空间还没用，就开始扩容了），对空间形成严重浪费。若是咱们在构造方法中不指定，则系统默认加载因子为0.75，这是一个比较理想的值，通常状况下咱们是无需修改的。

       另外，不管咱们指定的容量为多少，构造方法都会将实际容量设为不小于指定容量的2的次方的一个数，且最大值不能超过2的30次方

      对HashMap想进一步深刻了解的朋友推荐看一下HashMap源码剖析：http://blog.csdn.net/ns_code/article/details/36034955

 

2、Hashtable简介

 

      Hashtable一样是基于哈希表实现的，一样每一个元素是一个key-value对，其内部也是经过单链表解决冲突问题，容量不足（超过了阀值）时，一样会自动增加。

      Hashtable也是JDK1.0引入的类，是线程安全的，能用于多线程环境中。

      Hashtable一样实现了Serializable接口，它支持序列化，实现了Cloneable接口，能被克隆。

      Hashtable和HashMap比较类似，感兴趣的朋友能够看“Hashtable源码剖析”这篇博客：http://blog.csdn.net/ns_code/article/details/36191279

下面主要介绍一下HashTable和HashMap区别

 

3、HashTable和HashMap区别

      一、继承的父类不一样

 

      Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但两者都实现了Map接口。

      二、线程安全性不一样

      javadoc中关于hashmap的一段描述以下：此实现不是同步的。若是多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

 

      Hashtable 中的方法是Synchronize的，而HashMap中的方法在缺省状况下是非Synchronize的。在多线程并发的环境下，能够直接使用Hashtable，不须要本身为它的方法实现同步，但使用HashMap时就必需要本身增长同步处理。（结构上的修改是指添加或删除一个或多个映射关系的任何操做；仅改变与实例已经包含的键关联的值不是结构上的修改。）这通常经过对天然封装该映射的对象进行同步操做来完成。若是不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在建立时完成这一操做，以防止对映射进行意外的非同步访问，以下所示：

      Map m = Collections.synchronizedMap(new HashMap(...));

      Hashtable 线程安全很好理解，由于它每一个方法中都加入了Synchronize。这里咱们分析一下HashMap为何是线程不安全的：

 

      HashMap底层是一个Entry数组，当发生hash冲突的时候，hashmap是采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。

咱们来分析一下多线程访问：

 

      （1）在hashmap作put操做的时候会调用下面方法：

 

[java]  view plain  copy
 
  1. // 新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。      
  2.     void addEntry(int hash, K key, V value, int bucketIndex) {      
  3.         // 保存“bucketIndex”位置的值到“e”中      
  4.         Entry<K,V> e = table[bucketIndex];      
  5.         // 设置“bucketIndex”位置的元素为“新Entry”，      
  6.         // 设置“e”为“新Entry的下一个节点”      
  7.         table[bucketIndex] = new Entry<K,V>(hash, key, value, e);      
  8.         // 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小      
  9.         if (size++ >= threshold)      
  10.             resize(2 * table.length);      
  11.     }  

 

      在hashmap作put操做的时候会调用到以上的方法。如今假如A线程和B线程同时对同一个数组位置调用addEntry，两个线程会同时获得如今的头结点，而后A写入新的头结点以后，B也写入新的头结点，那B的写入操做就会覆盖A的写入操做形成A的写入操做丢失

（      2）删除键值对的代码

 

[java]  view plain  copy
 
  1. <span style="font-size: 18px;">      </span>// 删除“键为key”的元素      
  2.     final Entry<K,V> removeEntryForKey(Object key) {      
  3.         // 获取哈希值。若key为null，则哈希值为0；不然调用hash()进行计算      
  4.         int hash = (key == null) ? 0 : hash(key.hashCode());      
  5.         int i = indexFor(hash, table.length);      
  6.         Entry<K,V> prev = table[i];      
  7.         Entry<K,V> e = prev;      
  8.      
  9.         // 删除链表中“键为key”的元素      
  10.         // 本质是“删除单向链表中的节点”      
  11.         while (e != null) {      
  12.             Entry<K,V> next = e.next;      
  13.             Object k;      
  14.             if (e.hash == hash &&      
  15.                 ((k = e.key) == key || (key != null && key.equals(k)))) {      
  16.                 modCount++;      
  17.                 size--;      
  18.                 if (prev == e)      
  19.                     table[i] = next;      
  20.                 else     
  21.                     prev.next = next;      
  22.                 e.recordRemoval(this);      
  23.                 return e;      
  24.             }      
  25.             prev = e;      
  26.             e = next;      
  27.         }      
  28.      
  29.         return e;      
  30.     }  

 

      当多个线程同时操做同一个数组位置的时候，也都会先取得如今状态下该位置存储的头结点，而后各自去进行计算操做，以后再把结果写会到该数组位置去，其实写回的时候可能其余的线程已经就把这个位置给修改过了，就会覆盖其余线程的修改

      （3）addEntry中当加入新的键值对后键值对总数量超过门限值的时候会调用一个resize操做，代码以下：

[java]  view plain  copy
 
  1. // 从新调整HashMap的大小，newCapacity是调整后的容量      
  2.     void resize(int newCapacity) {      
  3.         Entry[] oldTable = table;      
  4.         int oldCapacity = oldTable.length;     
  5.         //若是就容量已经达到了最大值，则不能再扩容，直接返回    
  6.         if (oldCapacity == MAXIMUM_CAPACITY) {      
  7.             threshold = Integer.MAX_VALUE;      
  8.             return;      
  9.         }      
  10.      
  11.         // 新建一个HashMap，将“旧HashMap”的所有元素添加到“新HashMap”中，      
  12.         // 而后，将“新HashMap”赋值给“旧HashMap”。      
  13.         Entry[] newTable = new Entry[newCapacity];      
  14.         transfer(newTable);      
  15.         table = newTable;      
  16.         threshold = (int)(newCapacity * loadFactor);      
  17.     }  

      这个操做会新生成一个新的容量的数组，而后对原数组的全部键值对从新进行计算和写入新的数组，以后指向新生成的数组。

 

      当多个线程同时检测到总数量超过门限值的时候就会同时调用resize操做，各自生成新的数组并rehash后赋给该map底层的数组table，结果最终只有最后一个线程生成的新数组被赋给table变量，其余线程的均会丢失。并且当某些线程已经完成赋值而其余线程刚开始的时候，就会用已经被赋值的table做为原始数组，这样也会有问题。

      三、是否提供contains方法

 

      HashMap把Hashtable的contains方法去掉了，改为containsValue和containsKey，由于contains方法容易让人引发误解。

      Hashtable则保留了contains，containsValue和containsKey三个方法，其中contains和containsValue功能相同。

咱们看一下Hashtable的ContainsKey方法和ContainsValue的源码：

[java]  view plain  copy
 
  1. public boolean containsValue(Object value) {      
  2.      return contains(value);      
  3.  }  

[java]  view plain  copy
 
  1. // 判断Hashtable是否包含“值(value)”      
  2.  public synchronized boolean contains(Object value) {      
  3.      //注意，Hashtable中的value不能是null，      
  4.      // 如果null的话，抛出异常!      
  5.      if (value == null) {      
  6.          throw new NullPointerException();      
  7.      }      
  8.     
  9.      // 从后向前遍历table数组中的元素(Entry)      
  10.      // 对于每一个Entry(单向链表)，逐个遍历，判断节点的值是否等于value      
  11.      Entry tab[] = table;      
  12.      for (int i = tab.length ; i-- > 0 ;) {      
  13.          for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) {      
  14.              if (e.value.equals(value)) {      
  15.                  return true;      
  16.              }      
  17.          }      
  18.      }      
  19.      return false;      
  20.  }  

 

[java]  view plain  copy
 
  1. // 判断Hashtable是否包含key      
  2.  public synchronized boolean containsKey(Object key) {      
  3.      Entry tab[] = table;      
  4. /计算hash值，直接用key的hashCode代替    
  5.      int hash = key.hashCode();        
  6.      // 计算在数组中的索引值     
  7.      int index = (hash & 0x7FFFFFFF) % tab.length;      
  8.      // 找到“key对应的Entry(链表)”，而后在链表中找出“哈希值”和“键值”与key都相等的元素      
  9.      for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {      
  10.          if ((e.hash == hash) && e.key.equals(key)) {      
  11.              return true;      
  12.          }      
  13.      }      
  14.      return false;      
  15.  }  

      下面咱们看一下HashMap的ContainsKey方法和ContainsValue的源码：

[java]  view plain  copy
 
  1. // HashMap是否包含key      
  2.     public boolean containsKey(Object key) {      
  3.         return getEntry(key) != null;      
  4.     }  

[java]  view plain  copy
 
  1. // 返回“键为key”的键值对      
  2.     final Entry<K,V> getEntry(Object key) {      
  3.         // 获取哈希值      
  4.         // HashMap将“key为null”的元素存储在table[0]位置，“key不为null”的则调用hash()计算哈希值      
  5.         int hash = (key == null) ? 0 : hash(key.hashCode());      
  6.         // 在“该hash值对应的链表”上查找“键值等于key”的元素      
  7.         for (Entry<K,V> e = table[indexFor(hash, table.length)];      
  8.              e != null;      
  9.              e = e.next) {      
  10.             Object k;      
  11.             if (e.hash == hash &&      
  12.                 ((k = e.key) == key || (key != null && key.equals(k))))      
  13.                 return e;      
  14.         }      
  15.         return null;      
  16.     }  

[java]  view plain  copy
 
  1. // 是否包含“值为value”的元素      
  2.     public boolean containsValue(Object value) {      
  3.     // 若“value为null”，则调用containsNullValue()查找      
  4.     if (value == null)      
  5.             return containsNullValue();      
  6.      
  7.     // 若“value不为null”，则查找HashMap中是否有值为value的节点。      
  8.     Entry[] tab = table;      
  9.         for (int i = 0; i < tab.length ; i++)      
  10.             for (Entry e = tab[i] ; e != null ; e = e.next)      
  11.                 if (value.equals(e.value))      
  12.                     return true;      
  13.     return false;      
  14.     }  

经过上面源码的比较，咱们能够获得第四个不一样的地方

 

      四、key和value是否容许null值

 

      其中key和value都是对象，而且不能包含重复key，但能够包含重复的value。

      经过上面的ContainsKey方法和ContainsValue的源码咱们能够很明显的看出：

      Hashtable中，key和value都不容许出现null值。可是若是在Hashtable中有相似put(null,null)的操做，编译一样能够经过，由于key和value都是Object类型，但运行时会抛出NullPointerException异常，这是JDK的规范规定的。
HashMap中，null能够做为键，这样的键只有一个；能够有一个或多个键所对应的值为null。当get()方法返回null值时，多是 HashMap中没有该键，也可能使该键所对应的值为null。所以，在HashMap中不能由get()方法来判断HashMap中是否存在某个键， 而应该用containsKey()方法来判断。

      五、两个遍历方式的内部实现上不一样

      Hashtable、HashMap都使用了 Iterator。而因为历史缘由，Hashtable还使用了Enumeration的方式 。

      六、hash值不一样

      哈希值的使用不一样，HashTable直接使用对象的hashCode。而HashMap从新计算hash值。

      hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值。

      Hashtable计算hash值，直接用key的hashCode()，而HashMap从新计算了key的hash值，Hashtable在求hash值对应的位置索引时，用取模运算，而HashMap在求位置索引时，则用与运算，且这里通常先用hash&0x7FFFFFFF后，再对length取模，&0x7FFFFFFF的目的是为了将负的hash值转化为正值，由于hash值有可能为负数，而&0x7FFFFFFF后，只有符号外改变，然后面的位都不变。

      七、内部实现使用的数组初始化和扩容方式不一样

      HashTable在不指定容量的状况下的默认容量为11，而HashMap为16，Hashtable不要求底层数组的容量必定要为2的整数次幂，而HashMap则要求必定为2的整数次幂。
      Hashtable扩容时，将容量变为原来的2倍加1，而HashMap扩容时，将容量变为原来的2倍。

      Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11，增长的方式是 old*2+1。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程