java源码分析---Hashtable

最新推荐文章于 2021-11-28 20:22:17 发布
最新推荐文章于 2021-11-28 20:22:17 发布
阅读量225 收藏 1
点赞数
分类专栏： java源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uftjtt/article/details/79298975
版权

Hashtable源码分析

1、Hashtable体系结构

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

由源码看到Hashtable继承了Dictionary，并实现了Map，Cloneable，Serializeble接口，而Hashtable的实现也是基于“数组和链表”的。
2、属性

    private transient Entry<?,?>[] table;
    private transient int count;
    private int threshold;
    private float loadFactor;
    private transient int modCount = 0;

table—>用来实现Hashtable的数组,默认大小为11.
注意：这是Hashtable与HashMap第二个不同的地方，Hashtable的默认容量大小为11，HashMap的默认容量大小为16且扩容的大小必须一直是2的幂次方。
count—>用来记录table数组中存储元素的个数
threshold—>扩容的门限，即如果数组table中存储的元素个数大于threshold，则扩大数组table的大小
loadFactor—>装载因子，默认值为0.75f,扩容门线threshold的值等于loadFactor与数组table的容量的乘积.
3、Hashtable的构造函数
通过源码了解到Hashtable有四个构造函数，但无论有多少个构造参数，最终都是调用了Hashtable(int initialCapacity, float 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;
        this.loadFactor = loadFactor;
        table = new Entry<?,?>[initialCapacity];
        threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    }

在无惨的情况下initialCapacity为初始容量,默认大小为 11，loadFactor为加载因子，默认大小为0.75f，好比是你的内容超过了 总长度了75%,就会自动扩容
4、常用方法
4.1 void addEntry(int hash, K key, V value, int index)
源码如下：

 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;
        }
        // Creates the new entry.
        @SuppressWarnings("unchecked")
        Entry<K,V> e = (Entry<K,V>) tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
    }

此方法首先检查table中元素个数与threshold的大小，若元素个数已经超过了threshold就需要进行扩容，扩容后会重新获取key的hashcode，并根据hashcode重新计算要存储的位置index.最后将要存储的数据存储到table[index]中。这里要注意的一点是，如果table[index]中已经有其它元素了，那么在同一个位子上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾，扩容用到了rehash()方法，源码如下：

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

        // overflow-conscious code
        int newCapacity = (oldCapacity << 1) + 1;
        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;
            }
        }
    }

rehash方法的实现思想如下：首先对原来的长度乘以2+1就为即将扩容的长度。然后新建一个newCapacity的数组，将原来的table数组的元素拷贝到新的数组中去即可
4.2 put(K key, V value)

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;
        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) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }

        addEntry(hash, key, value, index);
        return null;
    }

put方法存储数据的思想如下：首先根据拿到key的hashcode，然后根据hashCode找到此元素即将要存储的位置index.如果位置index已经有元素链表了，则在此链表中，寻找是否有key已经存在了，如果存在，则更新value值，如果不存在，则将此value存储在index位置上。从源码中可以看到，put方法首先检查value是否为null，如果为空，则抛异常。
注意：这也是Hashtable与HashMap的另一个不同点，在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。
在Hashtable中所有的方法都是用synchronized关键字进行了同步，而HashMap中的方法在缺省情况下是非同步的。在多线程并发的环境下，可以直接使用Hashtable，但是要使用HashMap的话就要自己增加同步处理了。
4.3 putAll(Map

    public synchronized void putAll(Map<? extends K, ? extends V> t) {
        for (Map.Entry<? extends K, ? extends V> e : t.entrySet())
            put(e.getKey(), e.getValue());
    }

源码比较简单，内部使用了put(K key, V value)实现
4.4 V get(Object key) 

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

get方法的思想也比较简单，如下：首先获取key的hashcode，然后根据hashcode得到存储位置index，最后在table[index]取出元素即可，不过要注意的是，这里可能存储了多个元素构成了一个链表，因此要进行一个key和hash的判断
4.5 V remove(Object key)

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

remove方法的思想也比较简单，类似于get方法，首先计算key的hashcode，然后找到对应的index，然后在链表中寻找对应的元素值，修改链表元素
5、Hashtable内部类
5.1 内部类Entry
源码如下：

private static class Entry<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Entry<K,V> next;

        protected Entry(int hash, K key, V value, Entry<K,V> next) {
            this.hash = hash;
            this.key =  key;
            this.value = value;
            this.next = next;
        }

        @SuppressWarnings("unchecked")
        protected Object clone() {
            return new Entry<>(hash, key, value,
                                  (next==null ? null : (Entry<K,V>) next.clone()));
        }

        // Map.Entry Ops

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        public V setValue(V value) {
            if (value == null)
                throw new NullPointerException();

            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }

        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;

            return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
               (value==null ? e.getValue()==null : value.equals(e.getValue()));
        }

        public int hashCode() {
            return hash ^ Objects.hashCode(value);
        }

        public String toString() {
            return key.toString()+"="+value.toString();
        }
    }

内部类Entry，都说Hashtable是数组和链表的结合体，而Entry就类似于起着链表的作用。
5.2 内部类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();
        }
    }

keySet继承了AbstractSet
5.3 内部类EntrySet

private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public Iterator<Map.Entry<K,V>> iterator() {
            return getIterator(ENTRIES);
        }

        public boolean add(Map.Entry<K,V> o) {
            return super.add(o);
        }

        public boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> entry = (Map.Entry<?,?>)o;
            Object key = entry.getKey();
            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.equals(entry))
                    return true;
            return false;
        }

        public boolean remove(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
            Object key = entry.getKey();
            Entry<?,?>[] tab = table;
            int hash = key.hashCode();
            int index = (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.hash==hash && e.equals(entry)) {
                    modCount++;
                    if (prev != null)
                        prev.next = e.next;
                    else
                        tab[index] = e.next;

                    count--;
                    e.value = null;
                    return true;
                }
            }
            return false;
        }

        public int size() {
            return count;
        }

        public void clear() {
            Hashtable.this.clear();
        }
    }

5.4 内部类ValueCollection

private class ValueCollection extends AbstractCollection<V> {
        public Iterator<V> iterator() {
            return getIterator(VALUES);
        }
        public int size() {
            return count;
        }
        public boolean contains(Object o) {
            return containsValue(o);
        }
        public void clear() {
            Hashtable.this.clear();
        }
    }
小潭渔
关注
专栏目录
源码分析 --- Java中HashMap、HashTable、ConcurrentHashMap
杨鑫newlife的专栏
07-09 373
零、先聊聊HashMap和HashTable以及ConcurrentHashMap HashTable 哈希表，是根据关键码值（key, Value）而直接进行访问的数据结构； 通过key，value映射到表中的一个位置来访问记录，加快查找速度。映射的函数叫做散列函数，存放的数组叫做散列表； HashTable继承了Directory，实现了Map、Cloneable、java.io.Serializable接口； H..
HashTable源码分析
vznv7p1h的专栏
02-22 294
本次分析代码为JDK1.8中HashTable代码。   HashTable不允许null作为key和value。   HashTable中的方法为同步的，所以HashTable是线程安全的。 Entry类 介绍 Entry是HashTable内的一个静态内部类，实现了Map.Entry接口。table的类型就是Entry。 基本参数 hash：存这个Entry的hash值
Java基础——HashTable源码分析
点击置顶文章查看博客目录（全站式导航）
05-22 2416
HashTable是什么 HashTable是基于哈希表的Map接口的同步实现 HashTable中元素的key是唯一的，value值可重复 HashTable中元素的key和value不允许为null，如果遇到null，则返回NullPointerException HashTable中的元素是无序的 public class Hashtable&lt;K,V&gt; e...
HashTable 源码分析
楠木大哥技术博客
08-03 439
基础元素结构如下： // The hash table data. // This cannot be serialised private struct bucket { public Object key; public Object val; public int hash_coll; // Store hash code; sign bit means there was a
java8集合源码分析-Outline:大纲
06-04
集合源码分析 JAVA： 基本语法 static 修饰变量 方法 静态块(初始化块 构造函数 ) 静态内部类() 静态导包 final() transient() foreach循环原理() volatile底层实现() equals和hashcode(, ) string,stringbuffer和...
java8集合源码分析-Petal:面试复习及面试经验
06-04
集合源码分析 开发面试常见问题整理 算法题：这个一般不难，剑指offer或者LeetCode easy题目，喜欢考排序，链表，树（红黑树、二叉排序树、完全二叉树、B+树区别） Java基础：集合类、HashMap/HashTable/...
javabitset源码-JerrySoundCode:杰瑞声码
06-04
bitset源码Java源码分析 基础集合列表 ArrayList (done) Vector (done) LinkedList (done) Stack (done) ReferenceQueue (done) ArrayDeque (done) Set HashSet (done) TreeSet (done) LinkedHashSet (done) BitSet ...
Java容器之Hashtable源码分析
12-21
【Java容器之Hashtable源码分析】 在Java编程中，`Hashtable`是一个古老的容器类，它继承自`Dictionary`接口，并实现了`Map`接口，同时也实现了`Cloneable`和`Serializable`接口。`Hashtable`与`HashMap`类似，都是...
Hashtable源码分析（基于JDK1.8）
xuhuaabc的博客
06-11 233
Hashtable 简介 Hashtable 存储的内容是键值对(key-value)映射，其底层实现是一个Entry数组+链表。 Hashtable是线程安全的它的key、value都不可以为null。此外，Hashtable中的映射不是有序的。且Hashtable大部分方法是用synchronized修饰，证明Hashtable是线程安全的。 Hashtable的继承结构 public cla...
【集合】HashTable 源码分析
yhl_jxy的博客
12-01 456
HashTable 源码分析，散列表数据结构分析......
Hashtable源码解析
m0_58438555的博客
11-28 347
hash表的数据结构：数组+链表 类的继承 public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable Dictionary 是个抽象类，jdk已经不建议继承了 类的属性 //实体对象 private transient Entry<?,?>[] table; private st
Hashtable简介
it_yangkun的博客
10-05 484
Hashtable简介 HashTable同样是基于哈希表实现的，同样每个元素都是key-value对，其内部也是通过单链表解决冲突问题，容量不足（超过了阈值）时，同样会自动增长。 Hashtable也是JDK1.0引入的类，是线程安全的，能用于多线程环境中。 Hashtable同样实现了Serializable接口，它支持序列化，实现了Cloneable接口，能被克隆。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值