JDK8 HashTable 源码分析

话不多说,直接上菜.............

  
    Hashtable存储的内容是键值对(key-value)映射,其底层实现是一个Entry数组+链表;


    Hashtable和HashMap一样也是散列表,存储元素也是键值对(JDK8 hashmap 加入了红黑树机制);


    HashMap允许key和value都为null,而Hashtable都不能为null,Hashtable中的映射不是有序的;


    Hashtable和HashMap扩容的方法不一样,Hashtable中数组默认大小11,扩容方式是 old*2+1。HashMap中数组的默认大小是16,而且一定是2的指数,增加为原来的2倍。


    Hashtable继承于Dictionary类(Dictionary类声明了操作键值对的接口方法),实现Map接口(定义键值对接口); Hashtable大部分类用synchronized修饰,证明Hashtable是线程安全的。


    HashMap的迭代器(Iterator)是fail-fast迭代器,而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了    HashMap的结构(增加或者移除元素),将会抛出ConcurrentModificationException,但迭代器本身的remove()方法移除元素则不会抛出  ConcurrentModificationException异常。

     table数组索引计算方式不同:hashmap    index = (n - 1) & hash   其hash算法:(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);int hash = key.hashCode();   hashtable     int index = (hash & 0x7FFFFFFF) % tab.length;

     HashMap中:initialCapacity=16,loadFactory=0.75 
     HashTable中:initialCapacity=11,loadFactory=0.75

  Java8,HashMap中,当出现冲突时,

  • 如果冲突数量小于8,则是以链表方式解决冲突。
  • 而当冲突大于等于8时,就会将冲突的Entry转换为红黑树进行存储。
  • 而又当数量小于6时,则又转化为链表存储。

  而在HashTable中,  则都是以链表方式存储。

 

其中原委,下面分析其中几个重要方法的分析,其中主要方法被synchronized修饰,故线程安全:

 首先是类成员变量


    // 键值对/Entry数组,每个Entry本质上是一个单向链表的表头
     
     private transient Entry<?, ?>[] table;
  
    //当前表中的Entry数量,如果超过了阈值,就会扩容,即调用rehash方法
    private transient int count;
  
    //rehash阈值
     private int threshold;
  
    // 负载因子
      private float loadFactor;
   
    /**
      * 用来实现"fail-fast"机制的(也就是快速失败)。所谓快速失败就是在并发集合中,其进行
      * 迭代操作时,若有其他线程对其进行结构性的修改,这时迭代器会立马感知到,并且立即抛出
      * ConcurrentModificationException异常,而不是等到迭代完成之后才告诉你(你已经出错了)。
      *HashTable大部分类被synchronized修饰,是线程安全的,没有fail-fast机制
     */
     private transient int modCount = 0;
   //下面是其构造方法,默认构造方法可从中看出容量默认大小为initialCapacity=11,负载因子loadFactor默认是0.75
    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);
    }

    //负载因子loadFactor默认是0.75
    public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }

   //容量默认大小为initialCapacity=11,负载因子loadFactor默认是0.75
    public Hashtable() {
        this(11, 0.75f);
    }

contains方法:判断是否含有该value的键值对,在Hashtable中hashCode相同的Entry用链表组织,看看Entry就是一个链表结构,key,value,hash值以及指向下一个节点的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();
        }
    }

 

hashCode不同的存储在Entry数组table中

     public synchronized boolean contains(Object value) {
        //hashtable不能为空,否则抛空异常
        if (value == null) {
            throw new NullPointerException();
        }

        Entry<?,?> tab[] = table;
        //从尾部向前查找
        for (int i = tab.length ; i-- > 0 ;) {
       //遍历每个不为空的链表结构,如果找到就返回
            for (Entry<?,?> e = tab[i] ; e != null ; e = e.next) {
                if (e.value.equals(value)) {
                    return true;
                }
            }
        }
        return false;
    }

put方法被synchronized修饰,将key和value放到map中,明显表明key和value不能为null,不然将抛出null异常

   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();
        //利用hashcode去除table.length,然后取长度。
        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;
    }

remove方法也被synchronized修饰,不是fast-fail机制

 public synchronized V remove(Object key) {
        Entry<?,?> tab[] = table;
        //获取key的hashcode
        int hash = key.hashCode();
        //计算索引
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        //获得索引出的链表
        Entry<K,V> e = (Entry<K,V>)tab[index];
        //遍历链表,找到需要的进行删除,modCount加一
        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) {
                 //那么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;
    }

get方法依然被synchronized修饰

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

rehash方法:当Hashtable中键值对总数超过阈值(容量*装载因子)后,内部自动调用rehash()增加容量,重新计算每个键值对的hashCode,int newCapacity = (oldCapacity << 1) + 1计算新容量 = 2 * 旧容量 + 1;并且根据新容量更新阈值。

 

protected void 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)
                // Keep running with MAX_ARRAY_SIZE buckets
                return;
            newCapacity = MAX_ARRAY_SIZE;
        }
        //新的Enrty数组,带着新的容量
        Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
         //散列表内的元素发生变化,modCount指针加1
        modCount++;
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        table = newMap;

        //把旧的链表重新计算index放入到新的链表中
        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;
            }
        }
    }

参考:https://blog.csdn.net/qq_29864971/article/details/79326106

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值