Hashtable 源码解析（jdk1.8）

最新推荐文章于 2022-08-12 17:50:07 发布
最新推荐文章于 2022-08-12 17:50:07 发布
阅读量447 收藏 1
点赞数
分类专栏： 集合框架 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011035026/article/details/123366047
版权
1、简述
  • HashTable 是 Map 接口线程安全版本的实现类，数据结构和方法实现与 HashMap 类似，不过目前基本上被弃用。
2、归纳
  • 继承 Dictionary，实现了 Map 接口，实现了 Cloneable 和 Serializable 接口，所以支持复制（拷贝）、序列化。
  • 底层是基于数组+单向链表实现的，无序，不可重复，不允许 null 键和 null 值存在。
  • 默认初始容量为11，默认负载因子为0.75，扩容时扩容为原来容量的2倍+1。
  • 采用 Synchronized 同步锁，锁方法方式锁住了整个 table 保证数据安全，在多线程竞争激烈的情况下效率非常低。
  • 单线程安全，多线程安全。
3、分析
3.1、静态内部类
  • HashtableEntry 为一个单向链表节点。
public class Hashtable<K, V> extends Dictionary<K, V>
        implements Map<K, V>, Cloneable, java.io.Serializable {
    
    ...

    private static class HashtableEntry<K,V> implements Map.Entry<K,V> {
        // END Android-changed: Renamed Entry -> HashtableEntry.
        final int hash;
        final K key;
        V value;
        HashtableEntry<K,V> next;

        protected HashtableEntry(int hash, K key, V value, HashtableEntry<K,V> next) {
            this.hash = hash;
            this.key =  key;
            this.value = value;
            this.next = next;
        }
        
        ...
    }
    
    ...
    
}
3.2、成员变量
public class Hashtable<K, V> extends Dictionary<K, V>
        implements Map<K, V>, Cloneable, java.io.Serializable {
    
    // 序列化唯一表示 UID
    private static final long serialVersionUID = 1421746759512286392L;

    // 内部采用 Entry 数组存储键值对数据，Entry 实际为单向链表的表头
    private transient HashtableEntry<?, ?>[] table;

    // HashTable 里键值对个数
    private transient int count;

    // 扩容阈值，当超过这个值时，进行扩容操作，计算方式为：数组容量*加载因子
    private int threshold;

    // 加载因子
    private float loadFactor;

    // 用于快速失败
    private transient int modCount = 0;
    
    ...
    
}
3.3、构造函数
public class Hashtable<K, V> extends Dictionary<K, V>
        implements Map<K, V>, Cloneable, java.io.Serializable {
    
    ...
    
    /**
     * 无参构造函数
     */
    public Hashtable() {
        this(11, 0.75f);
    }

    /**
     * 有参构造函数
     *
     * @param initialCapacity 初始容量
     */
    public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }

    /**
     * 有参构造函数
     *
     * @param initialCapacity 初始容量
     * @param 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;// 容量最小为1
        this.loadFactor = loadFactor;
        table = new HashtableEntry<?, ?>[initialCapacity];
        // 初始扩容阈值
        threshold = (int) Math.min(initialCapacity, MAX_ARRAY_SIZE + 1);
    }

    /**
     * 有参构造函数
     *
     * @param t Map集合
     */
    public Hashtable(Map<? extends K, ? extends V> t) {
        this(Math.max(2 * t.size(), 11), 0.75f);
        putAll(t);
    }
    
    ...
    
}
3.4、增操作
public class Hashtable<K, V> extends Dictionary<K, V>
        implements Map<K, V>, Cloneable, java.io.Serializable {
    
    ...
    
    /**
     * 增操作
     *
     * @param key   键
     * @param value 元素值
     * @return 返回添加成功后的元素值
     */
    public synchronized V put(K key, V value) {
        // 确保 value 值不为 null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        HashtableEntry<?, ?> tab[] = table;
        // 得到 key 的哈希值
        int hash = key.hashCode();
        // 得到该 key 存在到数组中的下标
        int index = (hash & 0x7FFFFFFF) % tab.length;
        // 得到该下标对应的 Entry
        @SuppressWarnings("unchecked")
        HashtableEntry<K, V> entry = (HashtableEntry<K, V>) tab[index];
        // 如果该下标的 Entry 不为 null，则进行链表遍历
        for (; entry != null; entry = entry.next) {
            // 遍历链表，如果存在 key 相等的节点，则替换这个节点的值，并返回旧值
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }
        // 如果数组下标对应的节点为空，或者遍历链表后发现没有和该 ke y相等的节点，则执行插入操作
        addEntry(hash, key, value, index);
        return null;
    }

    /**
     * 添加节点
     *
     * @param hash  哈希值
     * @param key   键
     * @param value 元素值
     * @param index 下标
     */
    private void addEntry(int hash, K key, V value, int index) {
        // 模数+1
        modCount++;

        HashtableEntry<?, ?> tab[] = table;
        // 判断是否需要扩容
        if (count >= threshold) {
            // 如果 count 大于等于扩容阈值，则进行扩容
            rehash();

            tab = table;
            // 扩容后，重新计算该 key 在扩容后 table 里的下标
            hash = key.hashCode();
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // 采用头插的方式插入，index 位置的节点为新节点的 next 节点
        // 新节点取代 inde 位置节点
        @SuppressWarnings("unchecked")
        HashtableEntry<K, V> e = (HashtableEntry<K, V>) tab[index];
        tab[index] = new HashtableEntry<>(hash, key, value, e);
        // count+1
        count++;
    }

    /**
     * 扩容操作
     */
    protected void rehash() {
        // 暂存旧的 table 和容量
        int oldCapacity = table.length;
        HashtableEntry<?, ?>[] oldMap = table;

        // 新容量为旧容量的 2n+1 倍
        int newCapacity = (oldCapacity << 1) + 1;
        // 判断新容量是否超过最大容量
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            // 如果旧容量已经是最大容量大话，就不扩容了
            if (oldCapacity == MAX_ARRAY_SIZE)
                // Keep running with MAX_ARRAY_SIZE buckets
                return;
            // 新容量最大值只能是 MAX_ARRAY_SIZE
            newCapacity = MAX_ARRAY_SIZE;
        }
        // 用新容量创建一个新 Entry 数组
        HashtableEntry<?, ?>[] newMap = new HashtableEntry<?, ?>[newCapacity];
        // 模数+1
        modCount++;
        // 重新计算下次扩容阈值
        threshold = (int) Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        // 将新 Entry 数组赋值给 table
        table = newMap;
        // 遍历数组和链表，进行新table赋值操作
        for (int i = oldCapacity; i-- > 0; ) {
            for (HashtableEntry<K, V> old = (HashtableEntry<K, V>) oldMap[i]; old != null; ) {
                HashtableEntry<K, V> e = old;
                old = old.next;

                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = (Entry<K, V>) newMap[index];
                newMap[index] = e;
            }
        }
    }
    
    ...

}
3.5、删操作
public class Hashtable<K, V> extends Dictionary<K, V>
        implements Map<K, V>, Cloneable, java.io.Serializable {
    
    ...
    
    /**
     * 根据 key 进行删操作
     *
     * @param key 键
     * @return 返回删除后的元素值
     */
    public synchronized V remove(Object key) {
        HashtableEntry<?, ?> tab[] = table;
        int hash = key.hashCode();
        // 获取 key 对应的 index
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        HashtableEntry<K, V> e = (HashtableEntry<K, V>) tab[index];
        // 遍历链表，如果找到 key 相等的节点，则改变前继和后继节点的关系，并删除相应引用，让 GC 回收
        for (HashtableEntry<K, V> 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;
    }

    /**
     * 根据键和值进行删操作
     *
     * @param key   键
     * @param value 元素值
     * @return 返回 true 代表删除成功，返回 false 代表删除失败
     */
    @Override
    public synchronized boolean remove(Object key, Object value) {
        Objects.requireNonNull(value);

        HashtableEntry<?, ?> tab[] = table;
        int hash = key.hashCode();
        // 获取 key 对应的 index
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        HashtableEntry<K, V> e = (HashtableEntry<K, V>) tab[index];
        for (HashtableEntry<K, V> prev = null; e != null; prev = e, e = e.next) {
            if ((e.hash == hash) && e.key.equals(key) && e.value.equals(value)) {
                modCount++;
                if (prev != null) {
                    prev.next = e.next;
                } else {
                    tab[index] = e.next;
                }
                count--;
                e.value = null;
                return true;
            }
        }
        return false;
    }
    
    ...
    
}
3.6、改操作
public class Hashtable<K, V> extends Dictionary<K, V>
        implements Map<K, V>, Cloneable, java.io.Serializable {

    ...
    
    /**
     * 根据键和值进行替换操作
     *
     * @param key   键
     * @param value 元素值
     * @return 返回替换前的旧值，如若不存在则返回 null
     */
    @Override
    public synchronized V replace(K key, V value) {
        Objects.requireNonNull(value);
        HashtableEntry<?, ?> tab[] = table;
        int hash = key.hashCode();
        // 根据 key 的 hash 值计算出数组下标
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        HashtableEntry<K, V> e = (HashtableEntry<K, V>) tab[index];
        for (; e != null; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                V oldValue = e.value;
                e.value = value;
                return oldValue;
            }
        }
        return null;
    }

    /**
     * 根据键和值进行替换操作
     *
     * @param key      键
     * @param oldValue 旧元素值
     * @param newValue 新元素值
     * @return 返回 true 代表替换成功，返回 false 代表替换失败
     */
    @Override
    public synchronized boolean replace(K key, V oldValue, V newValue) {
        Objects.requireNonNull(oldValue);
        Objects.requireNonNull(newValue);
        HashtableEntry<?, ?> tab[] = table;
        int hash = key.hashCode();
        // 根据 key 的 hash 值计算出数组下标
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        HashtableEntry<K, V> e = (HashtableEntry<K, V>) tab[index];
        for (; e != null; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                if (e.value.equals(oldValue)) {
                    e.value = newValue;
                    return true;
                } else {
                    return false;
                }
            }
        }
        return false;
    }
    
    ...
    
}
3.6、查操作
public class Hashtable<K, V> extends Dictionary<K, V>
        implements Map<K, V>, Cloneable, java.io.Serializable {

    ...

    /**
     * 根据 key 进行查操作
     *
     * @param key 键
     * @return 返回查找后的元素值，如若不存在返回 null
     */
    public synchronized V get(Object key) {
        HashtableEntry<?, ?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (HashtableEntry<?, ?> e = tab[index]; e != null; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V) e.value;
            }
        }
        return null;
    }
    
    ...

}
xing.tang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jdk1.8中hashtable源码分析
YYC的专栏
06-08 2356
注：基于JDK 1.8.0_131源代码为例进行分析 hashtable的结构图 hashtable采用桶位+链表结构实现。 hashtable的实现 采用的是“桶位”，即一个Entry数组实现： Entry节点的实现：主要包括了key、value以及key的哈希值和next指向想一个节点。 说明： 代码块1：为Entry节点中包含的key、value、...
HashTable源码(JDK1.7,含注释)
06-02
HashTable源码(JDK1.7,含注释)
哈希桶 entry_哈希表算法原理
weixin_39980082的博客
01-18 621
基本概念哈希表（Hash Table）是一种根据关键字直接访问内存存储位置的数据结构。通过哈希表，数据元素的存放位置和数据元素的关键字之间建立起某种对应关系，建立这种对应关系的函数称为哈希函数。哈希函数构造方法哈希表的构造方法是：假设要存储的数据元素个数为n，设置一个长度为m（m≥n）的连续存储单元，分别以每个数据元素的关键字 Ki(0<= i <=n-1) 为自变量，通过哈希函数 ...
HashTable源码解析
qq_50596778的博客
11-08 361
HashTable 属性成员 //hash表数组 private transient Entry<?,?>[] table; //元素个数 private transient int count; //扩容阈值 private int threshold; //负载因子 private float loadFactor; //改动次数 private transient int modCount = 0;
Java集合篇：Hashtable原理详解（JDK1.8）
张维鹏的博客
10-19 3299
（本文使用的源码基于JDK1.8的）   一、Hashtable的基本方法： 这部分参考博客：https://blog.csdn.net/chenssy/article/details/22896871 1、定义： HashTable在Java中的定义如下： public class Hashtable&lt;K,V&gt; extends Dictionary&lt;K,V...
JDK1.8之前与之后 HashMap底层实现原理的差别
最新发布
qq_51901495的博客
08-12 923
hashmap的概述 HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。 HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null，此外，HashMap中的映射不是有序的。 jdk1.8 之前 HashMap 由 数组 + 链表 组成，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突（两个对象调用的hashCode 方法计算的哈希值经哈希函数算出来的地址被别的元素占用）而存在的（“拉链法”
ConcurrentHashMap的实现原理(JDK1.7和JDK1.8)
11-15
ConcurrentHashMap 的实现原理(JDK1.7 和JDK1.8) 一、哈希表 哈希表是一种以键-值(key-indexed)存储数据的结构，我们只要输入待查找的值即 key，即可查找到其对应的值。哈希的思路很简单，如果所有的键都是整数，...
ConcurrentHashMap的实现原理(JDK1.7和JDK1.8).pdf
11-26
JDK1.8版本的`ConcurrentHashMap`进行了优化，参考了HashMap的改进，采用了数组+链表+红黑树的方式，并大量使用了CAS（Compare and Swap）操作，减少了锁的使用，进一步提高了并发性能。当链表长度超过一定阈值时，...
Java容器之Hashtable源码分析
12-21
【Java容器之Hashtable源码分析】 在Java编程中，`Hashtable`是一个古老的容器类，它继承自`Dictionary`接口，并实现了`Map`接口，同时也实现了`Cloneable`和`Serializable`接口。`Hashtable`与`HashMap`类似，都是...
Java源码解析HashMap简介
08-26
Java源码解析HashMap简介 HashMap是Java开发中最常用的集合之一，它基于hash表的实现，提供了map的所有可选操作，并且允许null值和一个null的key。HashMap的实现提供了常量级的性能，假设hash函数把元素们比较好的...
Java8改进的HashMap和Hashtable实现类
程序圆—脱颖而出，卓尔不群
09-17 1211
HashMap和Hashtable都是Map接口的典型实现类，它们之间的关系完全类似于ArrayList和Vector的关系：Hashtable是一个古老的Map实现类，它从JDK1.0起就已经出现了，当它出现时，Java还没有提供Map接口，所以它包含了两个繁琐的方法，即elements()（类似于Map接口定义的values()方法）和keys()（类似于Map接口定义的keySet()方法）
HashTable 源码解析 jdk1.8
kking_edc的博客
09-10 209
一、结构图 Hashtable采用桶位+链表结构实现，如下图所示： 二、属性 2.1 table 底层是一个存储Entry的数组 private transient Entry<?,?>[] table; 2.2 Entry 一个单向链表结构 private static class Entry<K,V> implements Map.Entry<K,V> { final int hash; final K key;
Java 8系列之重新认识HashMap
美团技术团队
06-24 1万+
摘要 HashMap是Java程序员使用频率最高的用于映射(键值对)处理的数据类型。随着JDK（Java Developmet Kit）版本的更新，JDK1.8对HashMap底层的实现进行了优化，例如引入红黑树的数据结构和扩容的优化等。本文结合JDK1.7和JDK1.8的区别，深入探讨HashMap的结构实现和功能原理。 简介 Java为数据结构中的映射定义了一个接口java.u...
hashTable源码解析
Y1230601的博客
08-16 696
概述 JDK 1.8中的HashTable是底层实现由“数组+链表”实现，相对于hashMap来说简单很多，而且他们两个最大的区别是hashTable是线程安全的，hashMap不是本文就HashTable中的几个常用的重要方法展开学习讨论。hashtable的数据结构是table数组，数组里面是链表 基本属性说明 /** * The hash table data. ...
HashTable类源码详解
LYQ20010417的博客
11-11 663
一、源码分析 1.继承的父类&实现的接口 public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable { 2.Entry节点类 /** * Hashtable bucket collision list entry * Entry节点类 */ privat
HashMap中Entry以及Hash值的理解
风的季节
05-10 1万+
HashMap的底层结构如下： HashMap的底层结构是数组+链表 数组： HashMap以键值对存储数据，其中Key-Value都是Map.Entry中的属性。数组的值对应Value值，数组的下标对应Key值，对应过程如下：将Key值进行Hash后得到Hash值，Hash值得范围大概40亿，很明显，内存存不下，进行转换，对数组的长度(即hashmap的长度)进行取模运算...
Hashtable的遍历(DictionaryEntry)
IT Tech
11-23 1205
定义可设置或检索的字典键/值对。 命名空间:System.Collections 程序集:mscorlib（在 mscorlib.dll 中） foreach 语句是对枚举数的包装，它只允许从集合中读取，不允许写入集合。 C# 语言中的 foreach 语句（在 Visual C++ 中为 for each，在 Visual Basic 中为 For Each）需要集合中每个元
HashTable原理和底层实现
热门推荐
欢迎光临
03-13 1万+
1. 概述 上次讨论了HashMap的结构，原理和实现，本文来对Map家族的另外一个常用集合HashTable进行介绍。HashTable和HashMap两种集合非常相似，经常被各种面试官问到两者的区别。 对于两者的区别，主要有以下几点： HashMap是非同步的，没有对读写等操作进行锁保护，所以是线程不安全的，在多线程场景下会出现数据不一致的问题。而HashTable是同步的，所有的读写等操作都...
HashTable源码分析
lebronchen的博客
08-22 319
1、HashTable概述 HashTable以key-value形式存储数据，key不允许为null，value也不允许为null。 HashTable线程安全。 HashTable对大量的方法都添加synchronized锁，所以性能不高。 HashTable底层是数组，又被称为hash桶，每个桶中存放的是链表，链表中的节点存储着集合中的元素。 当HashTable中的元素数量达到t...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值