Hashtable源码分析(1.8)

最新推荐文章于 2020-11-20 13:40:31 发布
最新推荐文章于 2020-11-20 13:40:31 发布
阅读量252 收藏
点赞数
分类专栏： 春招--面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44545800/article/details/106182904
版权

相比于hashMap,HashTable有以下特点：

 1、和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。Hashtable 的实例有同样有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量就是哈希表创建时的容量。在发生“哈希冲突”的情况下，单个桶会存储多个条目，这些条目必须按顺序搜索；加载因子是对哈希表在其容量自动增加之前可以达到多满的一个尺度。初始容量和加载因子这两个参数只是对该实现的提示，通常，默认加载因子是 0.75, 这是在时间和空间成本上寻求一种折中。

 2、Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口

public class Hashtable<K,V>extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable {

3、Hashtable 的函数都是同步的(用synchronized修饰)，这意味着它是线程安全的。但是它的key、value都不可以为null。

Hashtable中的映射不是有序的。

构造方法

hashtable包括几个重要的成员变量：table, count, threshold, loadFactor, modCount(解释略，与hashmap类似)

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)  //若初始容量为零，则会将初始变量赋值为1。不再为2的幂
            initialCapacity = 1;
        this.loadFactor = loadFactor;
//在构造函数中实例化hashtable,（hashmap在put方法中实例化）
        table = new Entry<?,?>[initialCapacity];
//阈值则会相应的取值（初始的阈值不在是2的幂）
        threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    }

   
    public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }

   
    public Hashtable() {   // 初始容量默认为11，加载因子默认为0.75
        this(11, 0.75f);
    }

   
    public Hashtable(Map<? extends K, ? extends V> t) {
        this(Math.max(2*t.size(), 11), 0.75f);//将初始容量与参数长度的3倍进行比较
        putAll(t);
    }

值得注意的：

  1. Hashtable的默认容量为11，默认负载因子为0.75.(HashMap默认容量为16，默认负载因子也是0.75)
  2. Hashtable的容量可以为任意整数，最小值为1，而HashMap的容量始终为2的n次方。
  3. 为避免扩容带来的性能问题，建议指定合理容量。
  4. 跟HashMap一样，Hashtable内部也有一个静态类叫Entry，其实是个键值对对象，保存了键和值的引用。

一般方法

1、put()方法

public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {  //当值为空的时候，抛出异常
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        Entry<?,?> tab[] = table;
//ox7FFFFFFF为‭01111111111111111111111111111111‬(‭2147483647‬)。通过键的hashcode取得相应的索引
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;  
        @SuppressWarnings("unchecked")
        Entry<K,V> entry = (Entry<K,V>)tab[index];
        for(; entry != null ; entry = entry.next) {
               //必须得重写hashcode,equals方法.如果键已经存在，则会直接替换旧值，并返回
            if ((entry.hash == hash) && entry.key.equals(key)) {  
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }
       // 添加新值
        addEntry(hash, key, value, index);
        return null;
    }

private void addEntry(int hash, K key, V value, int index) {
        modCount++;  //快速失败机制，标记修改
        Entry<?,?> tab[] = table;
        if (count >= threshold) { //若超出阈值，则扩容
            // Rehash the table if the threshold is exceeded
            rehash();

            tab = table;
            hash = key.hashCode();
            index = (hash & 0x7FFFFFFF) % tab.length;  //重新得到对应的索引值
        }

        // 创造新entry,其实用头部插入法(O(1))！！！(hashmap1.8使用的是尾部插入法(O(N)))        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>) tab[index];
        tab[index] = new Entry<>(hash, key, value, e);//将新建的entry插到首部
        count++;
    }

值得注意的：

  1. Hasbtable并不允许值和键为空（null），若为空，会抛空指针。
  2. HashMap计算索引的方式是h&(length-1),而Hashtable用的是模运算，效率上是低于HashMap的。
  3. 另外Hashtable计算索引时将hash值先与上0x7FFFFFFF,这是为了保证hash值始终为正数。
  4. 特别需要注意的是这个方法包括下面要讲的若干方法都加了synchronized关键字，也就意味着这个Hashtable是个线程安全的类，这也是它和HashMap最大的不同点.

2、rehash方法：

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

        // overflow-conscious code
        int newCapacity = (oldCapacity << 1) + 1;  //新容量变为2倍+1(hashmap为2倍)
        if (newCapacity - MAX_ARRAY_SIZE > 0) {  //不能超过规定的最大值。
            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);
        table = newMap;

        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;  //首部插入
            }
        }
    }

值得注意的：

  1. Hashtable每次扩容，容量都为原来的2倍加1，而HashMap为原来的2倍。
  2. hashtable采用的是遍历+尾部添加的方法，所以得到的链表元素是倒序的。每一个链表元素都需要重新计算index,

3、get方法

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

如果你传的参数为null，是会抛空指针的。

4、remove方法

		public synchronized V remove(Object key) {
			Entry tab[] = table;
			int hash = key.hashCode();
			int index = (hash & 0x7FFFFFFF) % tab.length;
			// 找到“key对应的Entry(链表)”
			// 然后在链表中找出要删除的节点，并删除该节点。
			for (Entry<K,V> e = tab[index], prev = null ; e != null ; prev = e, e = e.next) {
				if ((e.hash == hash) && e.key.equals(key)) {
					modCount++;
					if (prev != null) {
						prev.next = e.next;
					} else {
						tab[index] = e.next;
					}
					count--;
					V oldValue = e.value;
					e.value = null;
					return oldValue;
				}
			}
			return null;
		}

使用了pre节点来保存待删除节点的前驱节点。

其余方法：
synchronized void                clear()
synchronized Object              clone()
boolean             contains(Object value)
synchronized boolean             containsKey(Object key)
synchronized boolean             containsValue(Object value)
synchronized Enumeration<V>      elements()
synchronized Set<Entry<K, V>>    entrySet()
synchronized boolean             equals(Object object)
synchronized V                   get(Object key)
synchronized int                 hashCode()
synchronized boolean             isEmpty()
synchronized Set<K>              keySet()
synchronized Enumeration<K>      keys()
synchronized V                   put(K key, V value)
synchronized void                putAll(Map<? extends K, ? extends V> map)
synchronized V                   remove(Object key)
synchronized int                 size()
synchronized String              toString()
synchronized Collection<V>       values()

 hashTable迭代器：

首先看一下Enumeration的数据结构：

private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
        Entry<?,?>[] table = Hashtable.this.table;  //使用数组的结构形式
        int index = table.length;
        Entry<?,?> entry;
        Entry<?,?> lastReturned;
        int type;

        /**
         * Indicates whether this Enumerator is serving as an Iterator
         * or an Enumeration.  (true -> Iterator).
         */
        boolean iterator;

        /**
         * The modCount value that the iterator believes that the backing
         * Hashtable should have.  If this expectation is violated, the iterator
         * has detected concurrent modification.
         */
        protected int expectedModCount = modCount;

        Enumerator(int type, boolean iterator) {
            this.type = type;
            this.iterator = iterator;
        }

        public boolean hasMoreElements() {
            Entry<?,?> e = entry;
            int i = index;
            Entry<?,?>[] t = table;
            /* Use locals for faster loop iteration */
            while (e == null && i > 0) {
                e = t[--i];
            }
            entry = e;
            index = i;
            return e != null;   //判断时候还有元素
        }

        @SuppressWarnings("unchecked")
        public T nextElement() {
            Entry<?,?> et = entry;
            int i = index;
            Entry<?,?>[] t = table;
            /* Use locals for faster loop iteration */
            while (et == null && i > 0) {   
//从后向前遍历，若原数据的后继节点为空，则索引index前移
                et = t[--i];
            }
            entry = et;
            index = i;
            if (et != null) {  //链表是从前向后遍历
                Entry<?,?> e = lastReturned = entry;
                entry = e.next;   //待返回节点的后继节点
                return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);
            }
            throw new NoSuchElementException("Hashtable Enumerator");
        }

        // Iterator methods
        public boolean hasNext() {
            return hasMoreElements();
        }

        public T next() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            return nextElement();
        }

        public void remove() {
            if (!iterator)   //如果为false，则不允许删除操作
                throw new UnsupportedOperationException();
            if (lastReturned == null)
                throw new IllegalStateException("Hashtable Enumerator");
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();

            synchronized(Hashtable.this) {
                Entry<?,?>[] tab = Hashtable.this.table;
                int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length;

                @SuppressWarnings("unchecked")
                Entry<K,V> e = (Entry<K,V>)tab[index];
                for(Entry<K,V> prev = null; e != null; prev = e, e = e.next) {
                    if (e == lastReturned) {
                        modCount++;    //可以在遍历的时候，删除数据库
                        expectedModCount++;  //同时增加元素
                   //删除链表对应的节点
                        if (prev == null)       
                            tab[index] = e.next;
                        else
                            prev.next = e.next;
                        count--;
                        lastReturned = null;
                        return;
                    }
                }
                throw new ConcurrentModificationException();
            }
        }
    }

遍历方式：

1、通过collections来进行迭代(collections.iterator)(可以remove操作)

2、通过Enumeration遍历Hashtable的值或者键(不可remove操作)

//在职进行建或者值遍历的时候，是不能进行删除操作，只能遍历
public synchronized Enumeration<K> keys() {  //获取键对象
        return this.<K>getEnumeration(KEYS);
    }

public synchronized Enumeration<V> elements() {  //获取值对象
        return this.<V>getEnumeration(VALUES);
    }
private <T> Enumeration<T> getEnumeration(int type) {
        if (count == 0) {
            return Collections.emptyEnumeration();
        } else {
            return new Enumerator<>(type, false);  //若为false,则在迭代的时候，不能删除对象
        }
    }

3、根据entrySet()来获取Hashtable的“键值对”的Set集合(可以进行remove操作，本质上也是用枚举实现的)

public Set<Map.Entry<K,V>> entrySet() {
        if (entrySet==null)
            entrySet = Collections.synchronizedSet(new EntrySet(), this);
        return entrySet;
    }

    private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public Iterator<Map.Entry<K,V>> iterator() {
            return getIterator(ENTRIES);  //获得迭代器对象
        }

       ....
}
private <T> Iterator<T> getIterator(int type) {
        if (count == 0) {
            return Collections.emptyIterator();
        } else {  //获取枚举迭代器
            return new Enumerator<>(type, true);
        }
    }

4、使用keySet()来迭代(可以删除操作)

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

    private class KeySet extends AbstractSet<K> {
        public Iterator<K> iterator() {
            return getIterator(KEYS);
        }
        public int size() {
            return count;
        }
        public boolean contains(Object o) {
            return containsKey(o);
        }
        public boolean remove(Object o) {
            return Hashtable.this.remove(o) != null;
        }
        public void clear() {
            Hashtable.this.clear();
        }
    }

 值得注意的这种方法在获取值的时候，会遍历table，效率较低。

四种遍历方法实例

总结：

  1. Hashtable是个线程安全(synchronized)的类（HashMap线程不安全）；
  2. Hasbtable并不允许值和键为空（null），若为空，会抛空指针（HashMap可以）；
  3. Hashtable不允许键重复，若键重复，则新插入的值会覆盖旧值（同HashMap）；
  4. Hashtable同样是通过链表法解决冲突；
  5. Hashtable根据hashcode计算索引时将hashcode值先与上0x7FFFFFFF,这是为了保证hash值始终为正数;
  6. Hashtable的容量为任意正数（最小为1），而HashMap的容量始终为2的n次方。Hashtable默认容量为11，HashMap默认容量为16；
  7. Hashtable每次扩容，新容量为旧容量的2倍加1，而HashMap为旧容量的2倍；
  8. Hashtable和HashMap默认负载因子都为0.75;

参考连接：

                https://blog.csdn.net/dingjianmin/article/details/79774192

                https://blog.csdn.net/zcl1199/article/details/51372691 

晨沉辰
关注
专栏目录
jdk1.8中hashtable源码分析
YYC的专栏
06-08 2404
注：基于JDK 1.8.0_131源代码为例进行分析 hashtable的结构图 hashtable采用桶位+链表结构实现。 hashtable的实现 采用的是“桶位”，即一个Entry数组实现： Entry节点的实现：主要包括了key、value以及key的哈希值和next指向想一个节点。 说明： 代码块1：为Entry节点中包含的key、value、...
源码分析 CurrentHashMap 1.8
weixin_48886235的博客
12-03 1371
1.CurrentHashMap 数据结构 抛弃了 JDK 1.7 中原有的 Segment 分段锁，而采用了 CAS + synchronized 来保证并发安全性。 2 将 JDK 1.7 中存放数据的 HashEntry 改为 Node，但作用是相同的。 2 put方法 final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw new NullPoi
Hashtable源码解析（JDK1.8）
武培轩
03-21 337
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...
Java基础——HashTable源码分析
点击置顶文章查看博客目录（全站式导航）
05-22 2447
HashTable是什么 HashTable是基于哈希表的Map接口的同步实现 HashTable中元素的key是唯一的，value值可重复 HashTable中元素的key和value不允许为null，如果遇到null，则返回NullPointerException HashTable中的元素是无序的 public class Hashtable&lt;K,V&gt; e...
Hashtable源码解析
qq_39144393的博客
05-15 253
Hashtable是线程安全的，我们从源码来分析 代码很简单 Hashtable<String, String> ht = new Hashtable<String, String>(); ht.put("111", "http://blog.csdn.net/unix21/"); ht.put("222", "www.csdn.net"); ht.put("333", <a target=_blank href="http
Java并发系列之ConcurrentHashMap源码分析
08-27
Java并发系列之ConcurrentHashMap源码分析 ConcurrentHashMap是Java中一个高性能的哈希表实现，它解决了HashTable的同步问题，允许多线程同时操作哈希表，从而提高性能。 1. ConcurrentHashMap的成员变量： ...
HashMap 源码分析
12-22
然而，HashMap与HashTable的主要区别在于线程安全性：HashTable是线程安全的，而HashMap则不是。 JDK1.8之后，HashMap进行了性能优化，引入了红黑树的数据结构。当链表的长度超过一个阈值（默认为8）时，HashMap会...
ConcurrentHashMap1.8源码分析
程序人生|
12-27 366
文章简介 想必大家对HashMap数据结构并不陌生，JDK1.7采用的是数组+链表的方式，JDK1.8采用的是数组+链表+红黑树的方式。虽然JDK1.8对于HashMap有了很大的改进，提高了存取效率，但是线程安全的问题不可忽视，所以就有了线程安全的解决方案，比如在方法上加synchronized同步锁的HashTable，或者并发包中的ConcurrentHashMap线程安全类，本文就来和大家...
带你深入浅出的分析 HashTable 源码
Java极客技术
11-08 206
Hashtable 一个元老级的集合类，早在 JDK 1.0 就诞生了，今天小编想和大家一起来揭开它的面纱！01、摘要在集合系列的第一章，咱们了解到，Map 的实现类有 ...
jdk1.8的Hashtable源码解析
qq_29864971的博客
02-14 2031
Hashtable声明public class Hashtable&lt;K,V&gt; extends Dictionary&lt;K,V&gt; implements Map&lt;K,V&gt;, Cloneable, java.io.Serializable    Hashtable继承于Dictionary类（Dictionary类声明了操作键值对的接口方法），实现Map接口（定义键值对...
JDK-1.8 HashTable源码分析
KLordy的博客
03-05 332
  文章分析源码依托版本为JDK1.8，先看看HashTable的类关系图，如下：   对于HashTable而言，我们先看它的容器存储结构，关于这一系列容器的源码首先理解了它们设计的存储结构后，相关方法的基本实现思路就能知道个大概了，这里关于HashTable而言，它的存储结构设计还是比较简单的，主要理解一下几个参数即可： private transient Entry&lt;?,?&g...
Hashtable源码分析（基于JDK1.8）
xuhuaabc的博客
06-11 265
Hashtable 简介 Hashtable 存储的内容是键值对(key-value)映射，其底层实现是一个Entry数组+链表。 Hashtable是线程安全的它的key、value都不可以为null。此外，Hashtable中的映射不是有序的。且Hashtable大部分方法是用synchronized修饰，证明Hashtable是线程安全的。 Hashtable的继承结构 public cla...
HashTable源码分析
Mr.Lee
12-26 440
一、前言前面几篇介绍了List相关的几个类。本篇开始分析Map相关的集合常用类的源码，OK，从HashTable开始分析。我们知道HashTable是线程安全的，但是其实现实中我们使用它的概率却比线程不安全的HashMap要低，为什么呢？二、源码分析内部数据结构// 哈希表,内部使用单链表解决冲突,容量不足也会自动增长,transient保证不会被序列化 private transient Entr
HashTable1.8源码解读
理科男同学
11-20 586
目录 1，哈希表的简介 1.1，HashTable的构造函数 1.2，HashTable的属性说明 1.3，HashTable的PAI 2，HashTable的数据结构 2.1，HashTable的内部类 2.2，HashTable中重要方法分析 2.2.1，put()方法 2.2.2，addEntry()方法 2.2.3，rehash()方法 2.2.4，get()方法 2.2.5，remove()删除元素方法 2.3，哈希别中其他方法说明 2.3.1，clear()方法 2
Android AIDL与Java Hashtable源码分析与学习
资源摘要信息:"aidl, java开源项目源码, Java的hashtable的源码" 知识点详细说明： 1. Android内部进程通信接口（AIDL） AIDL（Android Interface Definition Language）是Android中用于实现进程间通信（IPC）的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值