Java鸠合-08HashMap源码剖析及运用实例_玖富娱乐主


玖富娱乐是一家为代理招商,直属主管信息发布为主的资讯网站,同时也兼顾玖富娱乐代理注册登录地址。

HashMap 简介

HahMap是基于hash表的Map接口完成。该完成供应一切可选的映照操纵,且许可key和value为null。同时
它不是线程平安和不克不及包管有序。初始容量(initial capacity)和加载因子(initial capacity)是影响
HashMap的两个要素。容量透露显示hash表中桶(buckets)的数量,初始容量就是透露显示hash表在建立时刻容量巨细。
加载因子就是hash表在其容量自动增添时刻被许可填满水平的目标。当hash表中条目数凌驾以后hash表容量
与加载因子的乘积时刻,hash表将举行rehash操纵(重修内部数据组织),从而hash表的桶数量约莫增进两倍。

一般加载因子为0.75,这个值是时候和空间斲丧的一个均衡值。太高的值下降了空间斲丧然则却增添了查询本钱。
在设置初始化容量时刻须要斟酌Map中的条目数和加载因子,以便削减rehash操纵。若是初始容量的值大于最大条目数除以加载因子,
将不会发作rehash操纵。

若是你要运用HashMap存储映照干系时刻,有一个足够的容量是比让HashMap自动rehash来增添容量越发有效率。须要提示的是
运用具有雷同的hashCode()的键是会下降hash表的显示。为了制止hash碰撞,键若是是Comparable的话,对解开结有肯定的资助。

由于HashMap不是线程平安的,在多线程并发编程时刻,若是有最少一个线程在对HashMap组织修正(组织修正指的是增加
或许削减映照干系,关于本来有的一个映照转变它的值不是组织上的修正),必需包管同步化操纵。一般来讲运用某一工具加锁,
若是没有这么一个工具的话,该HashMap须要用Collections#synchronizedMap对其从新包裹

HashMap 组织函数

  1. public HashMap()

    界说一个初始容量为16,加载因子为0.75的HashMap

  2. public HashMap(int initialCapacity)

    界说一个指定初始容量,加载因子为0.75的HashMap

  3. public HashMap(int initialCapacity, float loadFactor)

    界说一个指定初始容量和加载因子的HashMap

  4. public HashMap(Map<? extends K, ? extends V> m)

    界说一个初始容量为不小于(m.size()/0.75 1)的2的最小指数,加载因子为0.75,包含了m中映照干系的HashMap

HashMap 组织图

  • table

    用于存储数据

  • entrySet

    entrySet()要领的缓存值

  • size

    map中映照个数

  • modCount

    fail-fast推断运用

    -玖富娱乐是一家为代理招商,直属主管信息发布为主的资讯网站,同时也兼顾玖富娱乐代理注册登录地址。-
  • threshold

    resize操纵的阙值,巨细为capacity * load factor

  • loadFactor

    加载因子

HashMap 源码剖析

  • Node
    • hash表中每一个节点存储工具
    static class Node<K,V> implements Map.Entry<K,V>{
      final int hash;
      final K key;
      V value;
      Node<K,V> next;
    
      Node(int hash, K key, V value, Node<K,V> next) {
          this.hash = hash;
          this.key = key;
          this.value = value;
          this.next = next;
      }
      //省略set、get等要领
    }
  • 扩容要领
final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;//扩容前的hash表指向oldTab
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {//凌驾最大值,后续不再扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }//没有凌驾最大值,容量扩展一倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    if (newThr == 0) {//设置扩容阙值
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {//本来的数据移动到新的容器内里
        for (int j = 0; j < oldCap;   j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j   oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}
  • 增加要领
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {//hash函数,用于索引定位
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;//存储数据Node没有初始化,此时初始化
    if ((p = tab[i = (n - 1) & hash]) == null)//(n-1)&hash用于定位,若为null,注解Node数组该地位没有Node工具,即没有碰撞
        tab[i] = newNode(hash, key, value, null);//对应地位增加Node工具
    else {//注解对应地位是有Node工具的,hash碰撞了
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))//碰撞了,且桶中第一个节点就婚配
            e = p;//纪录第一个节点
        else if (p instanceof TreeNode)//碰撞了,第一个节点没有婚配上,且桶为红黑树组织,挪用红黑树组织要领增加映照
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {//碰撞了 不为红黑树组织,那末是链表组织
            for (int binCount = 0; ;   binCount) {
                if ((e = p.next) == null) {//若是到了链表尾端
                    p.next = newNode(hash, key, value, null);//链尾增加映照
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st//链表长度大于TREEIFY_THRESHOLD值,转换为红黑树组织
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))//若是找到反复的key,推断该节点和要插进去的元素key是不是相称,若是相称,出轮回
                    break;
                p = e;//为了遍历,和e = p.next连系来遍历
            }
        }
        if (e != null) { // existing mapping for key//key映照的节点不为空
            V oldValue = e.value;//掏出节点值纪录为老的节点值
            if (!onlyIfAbsent || oldValue == null)//若是onlyIfAbsent为false,或许老的节点值为null,给予新的值
                e.value = value;
            afterNodeAccess(e);//接见后回调
            return oldValue;
        }
    }
      modCount;//组织性修正纪录
    if (  size > threshold)//推断是不是须要扩容
        resize();
    afterNodeInsertion(evict);//插进去后回调
    return null;
}

put流程

1.经由过程hash函数盘算key的hash值,挪用putVal要领

2.若是hash表为空,挪用resize()要领建立一个hash表

3.依据hash值索引hash表对应桶地位,推断该地位是不是有hash碰撞

3.1 没有碰撞,直接插进去映照入hash表

3.2 有碰撞,遍历桶中节点

3.2.1 第一个节点婚配,纪录该节点

3.2.2 第一个节点没有婚配,桶中组织为红黑树组织,依照红黑树组织增加数据,纪录返回值

3.2.3 第一个节点没有婚配,桶中组织是链表组织。遍历链表,找到key映照节点,纪录,退出轮回。
没有则在链表尾部增加节点。插进去后推断链表长度是不是大于转换为红黑树请求,相符则转为红黑树组织

3.2.4 用于纪录的值推断是不是为null,不为则是须要插进去的映照key在hash表中本来有,替代值,返回旧值putValue要领完毕

4.组织性修正纪录,推断是不是须要扩容

  • get要领
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {//hash表存在且长度大于0且对应的key定位的桶不为null
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;//第一个节点相符 返回第一个
        if ((e = first.next) != null) {//第一个不相符,若是链表另有下一个节点 
            if (first instanceof TreeNode)//为红黑树组织
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);//依照红黑树组织查找
            do {//遍历链表,查询hash 和equals相称的,有则返回,一直到链尾
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}
  • 修正要领
public V replace(K key, V value) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) != null) {//依据key查询  有则修正
        V oldValue = e.value;
        e.value = value;
        afterNodeAccess(e);
        return oldValue;
    }
    return null;
}

  • remove要领
public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {//hash表存在且长度大于0且对应的key定位的桶不为null
        Node<K,V> node = null, e; K k; V v;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;//推断第一个节点,相符纪录
        else if ((e = p.next) != null) {//第一个节点不相符
            if (p instanceof TreeNode)//推断是不是为红黑树组织
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {//为链表组织,遍历
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {//推断是不是相符有要移除的node
            if (node instanceof TreeNode)//为红黑树组织
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)//第一个节点就是相符的
                tab[index] = node.next;//删除第一个节点(第一个节点指向null,或许指向本来第二个节点)
            else
                p.next = node.next;//链表组织,指向背面的一个节点
              modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

HashMap遍历

  • 遍历HashMap键值对

    依据map.entrySet()取得键值对Set鸠合,后续遍历

for (Map.Entry<Integer, String> entry : maps.entrySet()) {
    System.out.println(entry.getKey() ":" entry.getValue());
}
  • 遍历HashMap的键视图

    依据maps.keySet()取得HashMap的键的Set鸠合,后续遍历

for (Integer integer : maps.keySet()) {
    System.out.println(integer);
}
  • 遍历HashMap的值视图

    依据maps.values()取得HashMap的键的Collection鸠合,后续遍历

for (String value : maps.values()) {
    System.out.println(value);
}
-玖富娱乐是一家为代理招商,直属主管信息发布为主的资讯网站,同时也兼顾玖富娱乐代理注册登录地址。