jdk1.8的Hashtable源码解析

最新推荐文章于 2021-10-21 16:06:12 发布
最新推荐文章于 2021-10-21 16:06:12 发布
阅读量2k 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： Java集合学习笔记 文章标签： Hashtable源码 jdk1.8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_29864971/article/details/79326106
本文详细解析了Hashtable的内部结构、重要变量及方法，对比了它与HashMap的主要区别。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Hashtable声明

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable
    Hashtable继承于Dictionary类（Dictionary类声明了操作键值对的接口方法），实现Map接口（定义键值对接口）；

    Hashtable大部分方法都加了synchronized关键字，所以虽然是线程安全的，但在多线程并发环境下的效率较低。                     

1、Hashtable的几个重要变量

  • private transient Entry<?,?>[] table：键值对/Entry数组，每个Entry本质上是一个单向链表的表头

  • private int threshold：rehash阈值，当超过该阈值会rehash（重排序）

  • private float loadFactor：装填因子

  • private transient int modCount = 0： Hashtable结构化修改次数，用来实现fail-fast机制；

  • private transient volatile Set<Map.Entry<K,V>> entrySet：键值对集合，不可重复；

  • private transient volatile Set<K> keySet：key的集合，不可重复；

  • private transient volatile Collection<V> values：value集合，可重复；

  • private static final int Max_ARRAY_SIZE = Integer.MAX_VALUE-8;：散列表容量经过n次扩容之后，设置上限的阈值

2、Hashtable的几个内部类

键值对—Entry

private static class Entry<K,V> implements Map.Entry<K,V> {
    final int hash;    //哈希值
    final K key;       //key
    V value;           //value
    Entry<K, V> next;  //下一个entry结点
    ...
    // 计算键值对的hashCode
    public int hashCode() {
        // "^" 按位异或, hash在调用构造器时传入
        return hash ^ Objects.hashCode(value);
    }
}

Value集合——ValueCollection

private class ValueCollection extends AbstractCollection<V> {

        public Iterator<V> iterator() {

            return getIterator(VALUES);

        }

        public int size() {

            returncount;

        }

        public boolean contains(Object o) {

            return containsValue(o);

        }

        public void clear() {

            Hashtable.this.clear();

        }

    }

EntrySet集合

private class EntrySet extendsAbstractSet<Map.Entry<K,V>> {

        public Iterator<Map.Entry<K,V>>iterator() {

            return getIterator(ENTRIES);

        }

        publicboolean add(Map.Entry<K,V> o) {

            returnsuper.add(o);

        }

        ......

}      

Keys集合

private class KeySet extendsAbstractSet<K> {

        public Iterator<K> iterator() {

            return getIterator(KEYS);

        }

        publicint size() {

            returncount;

        }

        public boolean contains(Object o) {

            return containsKey(o);

        }

        public boolean remove(Object o) {

            return Hashtable.this.remove(o) != null;

        }

        publicvoid clear() {

            Hashtable.this.clear();

        }

    }

3、Hashtable几个重要的方法分析

     主要方法：Hashtable()、contains()、get()、rehash()、addEntry()、put(K,V)、remove(Object)，像size()、keys()、values()、isEmpty()、elements()比较简单就不一一介绍了。

(1) Hashtable

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); 

//threshold的计算方式，MAX_ARRAY_SIZE防止经过n次扩容后，数组大小超出整数的最大值，所以这里设定一个上限的阈值

}

   public Hashtable() { 

         this(11, 0.75f); //默认的table容量为11，装载因子为0.75

 }

(2) contains

public synchronized boolean contains(Object value) {

      if (value == null) {    //Hashtable的value不允许为空，不然会报空指针

                thrownew NullPointerException();

      }  

            Entry<?,?> tab[] = table;

            //从数组的最后往前遍历

            for (int i = tab.length ; i-- > 0 ;) {

            //再对每个entry链表进行遍历

                for (Entry<?,?> e = tab[i] ; e != null ; e = e.next) {

            //如果找到对应的value，返回true

                   if (e.value.equals(value)) {        

                       return true;

                   }

                }

            }

            //没找到返回false

            return false;

}

(3) containsKey

public synchronized boolean containsKey(Object key) {

            Entry<?,?> tab[] = table;

            int hash = key.hashCode();

            //计算数组的索引，Hashtable本质上采用除数取余法进行散列分布

            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;

}

(4) get

public synchronized V get(Object key) {

            Entry<?,?> tab[] = table;

            int hash = key.hashCode();

            //通过key的hash值和table的length，经过运算得到散列表中的索引

            int index = (hash & 0x7FFFFFFF) %tab.length;

            //遍历tab[index]对应的链表

            for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {

            //如果entry的key和hash值与期望值一致，则返回

                if ((e.hash == hash) && e.key.equals(key)){

                   return (V)e.value;

                }

            }

            //否则返回空值

            return null;

 }

(4) rehash

@SuppressWarnings("unchecked")

        protectedvoid rehash() {

            //保存旧的容量和Entry数组

            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)            

                   return;

                newCapacity = MAX_ARRAY_SIZE;

            }

            //定义新的数组

            Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

            //此时，散列表内的元素发生变化，modCount指针加1

            modCount++;

            //重新计算新的threshold

            threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE+ 1);

            table = newMap;

           

            //对散列表内的所有元素进行“重排列”，顺序从后往前

            for (int i = oldCapacity ; i-- > 0 ;) {

                //遍历oldMap[i]对应的entry链表

                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;

                /**

                 * 可能e.next = (Entry<K,V>)newMap[index];和newMap[index] = e;比较生硬，我们举例说明

                 * 第一次遍历时，newMap[index]为null,所以 e.next=null

                 * 第二次遍历时，假定e1=e.next, 然后 e1.next = e, newMap[index] = e1（起始点为e1）

                 * ...

                 * 依次进行，会发现链表中插入元素的顺序是“从左往右”

                 */

                }

            }

  }

(5) addEntry

private void addEntry(int hash, K key, V value, int index) {

             //modCount指针，对于修改操作不会自增，而对于内部元素数量的变化会自增

               modCount++;

               Entry<?,?> tab[] = table;

               //如果count大于阈值

               if (count >= threshold) {

                   //进行重排列操作

                    rehash();

                    tab = table;

                    hash = key.hashCode();

                    index = (hash & 0x7FFFFFFF) %tab.length;

               }

               //如果不大于阈值，则直接插入

               @SuppressWarnings("unchecked")

               Entry<K,V> e = (Entry<K,V>) tab[index];

               //如果e为空，将插入到起始位置，如果e不为空，则从左向右插入

                tab[index] = new Entry<>(hash, key, value, e);

                count++;

      }

(6) put

下图为jdk1.8的hashMap的put方法的过程，Hashtable和其类似，基本上“计算索引，逻辑判断”这个部分是一致的，差别在于Hashtable中没有用到红黑树。

                             

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

            // 首先value不能为空

            if (value == null) {

                throw new NullPointerException();

            }                   

            Entry<?,?> tab[] = table;

            int hash = key.hashCode();

            int index = (hash & 0x7FFFFFFF) %tab.length;

            @SuppressWarnings("unchecked")

            //判断tab[index]是否已经有值

            Entry<K,V> entry = (Entry<K,V>)tab[index];

            //如果有值，则遍历

            for(; entry != null ; entry = entry.next) {

                //如果key重复，那么新的value覆盖旧值

                if ((entry.hash == hash) &&entry.key.equals(key)) {

                   V old = entry.value;

                   entry.value = value;

                   return old;

                }

            }

            //经过遍历，发现key并没有重复，进行插入操作

            addEntry(hash, key, value, index);

            return null;

   }

(7) remove

public synchronized V remove(Object key) {

            Entry<?,?> tab[] = table;

            int hash = key.hashCode();

            //计算索引

            int index = (hash & 0x7FFFFFFF) %tab.length;

            @SuppressWarnings("unchecked")

            //获得索引位置对应的Entry链表

            Entry<K,V> e = (Entry<K,V>)tab[index];

            //遍历链表中的entry元素

            for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {

                //如果找到需要的entry，进行删除

                if ((e.hash == hash) &&e.key.equals(key)) {

                   //修改指针加1

                   modCount++;

                   //如果prev结点非空

                   if (prev != null) {

                       //那么pre结点的next指针指向e的next,等价于e被删除

                       prev.next = e.next;

                   } else {

                       //否则，说明需要删除的为起始结点

                       tab[index] = e.next;

                   }

                   count--;

                   V oldValue = e.value;

                   e.value = null;

                   return oldValue;

                }

            }

            return null;

}

HashMap和Hashtable的区别

  1. HashMap是非线程安全的，Hashtable是线程安全的，所以Hashtable重量级一些，因为使用了synchronized关键字来保证线程安全。
  2. HashMap允许key和value都为null，而Hashtable都不能为null。
  3. Hashtable继承自 JDK 1.0 的 Dictionary 虚拟类，而HashMap是 JDK 1.2 引进的 Map 接口的一个实现。
  4. Hashtable和HashMap扩容的方法不一样，Hashtable中数组默认大小11，扩容方式是 old*2+1。HashMap中数组的默认大小是16，而且一定是2的指数，增加为原来的2倍。
  5. 两者通过hash值散列到hash表的算法不一样，Hashtable是古老的除留余数法，直接使用Object的hashcode，而后者是强制容量为2的幂，重新根据hashcode计算hash值，在使用hash和（hash表长度 – 1）进行与运算，也等价取膜，但更加高效，取得的位置更加分散，偶数，奇数保证了都会分散到。前者就不能保证。
  6. HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。以下面测试case为例：
     

    //测试Hashtable是否是“fast-fail"机制

    @Test

    public void test2() {

        Hashtable<String,String> table = new Hashtable<String,String>();

        table.put("a", "gao");

        table.put("b", "zhu");

        table.put("c", "zhang");

        table.put("d", "sun");

       

        Iterator<String> keys =table.keySet().iterator();

        while(keys.hasNext()) {

            String s = keys.next();

            if("c".equals(s)) {

                table.remove(s);

            }else {

                System.out.println(s);

            }

        }

    }

    //测试HashMap是否是"fast-fail"机制

    @Test

    public void test3() {

        Map<String,String> table2 = new HashMap<String,String>();

        table2.put("a", "gao");

        table2.put("b", "zhu");

        table2.put("c", "zhang");

        table2.put("d", "sun");

       

        Iterator<String> keys =table2.keySet().iterator();

        while(keys.hasNext()) {

            String s = keys.next();

            if("c".equals(s)) {

                table2.remove(s);

            }else {

                System.out.println(s);

            }

        }      

    }

结果发现：Hashtable不会报ConcurrentModificationException异常，而HashMap会！说明Hashtable的enumerator迭代器不是遵循fail-fast机制的。


 


 




HashTable源码分析
vznv7p1h的专栏
02-22 346
本次分析代码为JDK1.8中HashTable代码。   HashTable不允许null作为key和value。   HashTable中的方法为同步的，所以HashTable是线程安全的。 Entry类 介绍 Entry是HashTable内的一个静态内部类，实现了Map.Entry接口。table的类型就是Entry。 基本参数 hash：存这个Entry的hash值
JDK1.8 Hashmap源码解析
A_BCDEF_的博客
05-14 669
hashmap这样做是为了之后运算（位运算）方便，同时在hash时选择更好的hash函数，以抵消2的n次方带来的不便。index = (n - 1) & hash，如果这一位是0，则index = index，否则，index = index + oldCap。线程2唤醒开始执行扩容，此时线程2指向node1，且next节点为node2，但node2的next节点又为node1，出现死循环。扩容，就是给原来的容量乘2，也就是把原来容量oldCap左移一位，这时2^n的好处就表现出来了。
Hashtable源码解析（JDK1.8）
武培轩
03-21 388
package java.util; import java.io.*; import java.util.concurrent.ThreadLocalRandom; import java.util.function.BiConsumer; import java.util.function.Function; import java.util.function.BiFunction; i...
Hashtable源码解析
徐泗空的博客
04-21 388
Map--HashTable 上一篇文章中，我们分析了HashMap的源码，这一篇文章我们学习Map接口的另一个实现类---HashTable，在学习之前，不熟悉hashMap的可以先看我的上一篇文章Map--HashMap，我们需要先了解下它和HashMap有哪些异同点。 不同点 HashMap HashTable 继承的父类 Dictionary类 Abstra...
Hashtable源码分析（基于JDK1.8）
xuhuaabc的博客
06-11 293
Hashtable 简介 Hashtable 存储的内容是键值对(key-value)映射，其底层实现是一个Entry数组+链表。 Hashtable是线程安全的它的key、value都不可以为null。此外，Hashtable中的映射不是有序的。且Hashtable大部分方法是用synchronized修饰，证明Hashtable是线程安全的。 Hashtable的继承结构 public cla...
Java基础——HashTable源码分析
点击置顶文章查看博客目录（全站式导航）
05-22 2512
HashTable是什么 HashTable是基于哈希表的Map接口的同步实现 HashTable中元素的key是唯一的，value值可重复 HashTable中元素的key和value不允许为null，如果遇到null，则返回NullPointerException HashTable中的元素是无序的 public class Hashtable&lt;K,V&gt; e...
HashMap在JDK1.7和JDK1.8的区别（源码解读）
晓二当家的博客
10-21 2367
HashMap在JDK1.7和JDK1.8的区别 1.区别 存储结构不同：JDK1.7是数组+链表，JDK1.8则是数组+链表+红黑树结构; 初始化方式不同：JDK1.7中当哈希表为空时，会先调用inflateTable()初始化一个数组；而JDK1.8则是直接调用resize()扩容; 插入数据方式不同：插入键值对的put方法的区别，JDK1.8中会将节点插入到链表尾部，而JDK1.7中是采用头插，因为JDK1.7是用单链表进行的纵向延伸，当采用头插法时会容易出现逆序且环形链表死循环问题。但是在JDK1
ConcurrentHashMap源码解析（jdk1.8）
热门推荐
programmer_at的专栏
03-27 4万+
ConcurrentHashMap 基于JDK1.8 ConcurrentHashMap 1. 原理解析 1.1. 重要成员变量 1.2. 实例初始化 1.3. put操作 1.3.1 put过程描述 1.3.2 hash算法 1.3.3 定位索引 1.3.4 获取table对应的索引元素f 1.4. table 扩容 1.4.1 addCount 1.4.2 treeify ...
HashMap源码解析（基于JDK1.8）
m0_37884977的博客
06-02 1505
散列是一种用于以常数平均时间执行插入、删除和查找的技术。HashMap是基于哈希表的Map接口实现，该实现提供了所有可选的映射操作，并允许使用 空值和空键。（HashMap 类大致等同于Hashtable，除了它是不同步的并且允许为空值。）这个类不能保证Map的顺序; 特别是，它不能保证顺序会随着时间的推移保持不变。 下面就开始我们的源码分析吧： 老规矩，先贴一张UML图： ①：...
深入解析基于JDK1.8的Java集合类源码
资源摘要信息:"本文档提供了一份基于JDK 1.8版本的Java集合类源码的详细分析。集合类是Java编程语言中使用频率极高的组件，它们允许存储、管理和操作一组对象。在JDK 1.8中，集合框架有显著的改进和扩展，提供了更为...
java源码解析之Hashtable（jdk1.8）
weixin_40606398的博客
03-23 605
前言 前面两篇我们介绍了HashMap和LinkedHashMap。HashMap是jdk中最常用的哈希表实现，使用数组加链表的结构来组织数据，扩容操作会将之前的键值对顺序打乱。为了解决这个问题，jdk提供了LinkedHashMap。通过重写内部类Entry，新增两个成员属性LinkedHashMap.Entry类型的after和before，使所有的键值对序列都包含在一个双向链表上，并且不会受...
JDK-1.8 HashTable源码分析
KLordy的博客
03-05 365
  文章分析源码依托版本为JDK1.8，先看看HashTable的类关系图，如下：   对于HashTable而言，我们先看它的容器存储结构，关于这一系列容器的源码首先理解了它们设计的存储结构后，相关方法的基本实现思路就能知道个大概了，这里关于HashTable而言，它的存储结构设计还是比较简单的，主要理解一下几个参数即可： private transient Entry&lt;?,?&g...
Hashtable源码分析(1.8)
软件工程
05-18 285
相比于hashMap,HashTable有以下特点： 1、和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。Hashtable 的实例有同样有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量就是哈希表创建时的容量。在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索；加载因子是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示，通常，默认加载因子是 0.75.
HashTable1.8源码解析
JYX2333的博客
06-22 332
HashTable介绍： HashTable的底层实现是由“数组+链表”来实现的。和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。无论key还是value都不能为null，且线程安全，实现线程安全的方式是在修改数据时锁住整个HashTable，效率低。但是Hashtable是一种能提供快速插入和查询的数据结构，无论其包含多少Item（条目），执行查询和插入操作的平均时间复杂度总是接近O(1)。 HashTable源码解析： HashTable的继承关
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值