hashMap 1.8

Posted luyuefei

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了hashMap 1.8相关的知识,希望对你有一定的参考价值。

hashMap1.8并不能完全解决死循环的问题,可以用concurrentHashMap

hashMap的属性:

public class HashMap<K,V> extends AbstractMap<K,V>
   implements Map<K,V>, Cloneable, Serializable {
   //序列号,序列化的时候使用。
   private static final long serialVersionUID = 362498820763181265L;
   /**默认容量,1向左移位4个,00000001变成00010000,也就是2的4次方为16,使用移位是因为移位是计算机基础运算,效率比加减乘除快。**/
   static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
   //最大容量,2的30次方。
   static final int MAXIMUM_CAPACITY = 1 << 30;
   //加载因子,用于扩容使用。
   static final float DEFAULT_LOAD_FACTOR = 0.75f;
   //当某个桶节点数量大于8时,会转换为红黑树。
   static final int TREEIFY_THRESHOLD = 8;
   //当某个桶节点数量小于6时,会转换为链表,前提是它当前是红黑树结构。
   static final int UNTREEIFY_THRESHOLD = 6;
   //当整个hashMap中元素数量大于64时,也会进行转为红黑树结构。
   static final int MIN_TREEIFY_CAPACITY = 64;
   //存储元素的数组,transient关键字表示该属性不能被序列化
   transient Node<K,V>[] table;
   //将数据转换成set的另一种存储形式,这个变量主要用于迭代功能。
   transient Set<Map.Entry<K,V>> entrySet;
   //元素数量
   transient int size;
   //统计该map修改的次数
   transient int modCount;
   //临界值,也就是元素数量达到临界值时,会进行扩容。
   int threshold;
   //也是加载因子,只不过这个是变量。
   final float loadFactor;  

常用内部类

使用静态内部类,是为了方便调用,而不用每次调用里面的属性或者方法都需要new一个对象。这是一个红黑树的结构

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
       TreeNode<K,V> parent;  
       TreeNode<K,V> left;
       TreeNode<K,V> right;
       TreeNode<K,V> prev;    
       boolean red;
       TreeNode(int hash, K key, V val, Node<K,V> next) {
           super(hash, key, val, next);
      }
}

里面还包含了一个结点内部类,是一个单向链表。上面这两个内部类再加上之前的Node<K,V>[] table属性,组成了hashMap的结构,哈希桶。

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

构造方法:

    public HashMap() {
       this.loadFactor = DEFAULT_LOAD_FACTOR;
  }


   public HashMap(int initialCapacity) {
       this(initialCapacity, DEFAULT_LOAD_FACTOR);
  }


   public HashMap(int initialCapacity, float loadFactor) {
       if (initialCapacity < 0)
           throw new IllegalArgumentException("Illegal initial capacity: " +
                                              initialCapacity);
       if (initialCapacity > MAXIMUM_CAPACITY)
           initialCapacity = MAXIMUM_CAPACITY;
       if (loadFactor <= 0 || Float.isNaN(loadFactor))
           throw new IllegalArgumentException("Illegal load factor: " +
                                              loadFactor);
       this.loadFactor = loadFactor;
       this.threshold = tableSizeFor(initialCapacity);
  }

hash算法

static final int hash(Object key) {
      int h;
      /**先获取到key的hashCode,然后进行移位再进行异或运算,为什么这么复杂,不用想肯定是为了减少hash冲突**/
      return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  }

put方法

        public V put(K key, V value) {
           /**四个参数,第一个hash值,第四个参数表示如果该key存在值,如果为null的话,则插入新的value,最后一个参数,在hashMap中没有用,可以不用管,使用默认的即可**/
           return putVal(hash(key), key, value, false, true);
      }
   
       final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                      boolean evict) {
           //tab 哈希数组,p 该哈希桶的首节点,n hashMap的长度,i 计算出的数组下标
           Node<K,V>[] tab; Node<K,V> p; int n, i;
           //获取长度并进行扩容,使用的是懒加载,table一开始是没有加载的,等put后才开始加载
           if ((tab = table) == null || (n = tab.length) == 0)
               n = (tab = resize()).length;
           /**如果计算出的该哈希桶的位置没有值,则把新插入的key-value放到此处,此处就算没有插入成功,也就是发生哈希冲突时也会把哈希桶的首节点赋予p**/
           if ((p = tab[i = (n - 1) & hash]) == null)
               tab[i] = newNode(hash, key, value, null);
           //发生哈希冲突的几种情况
           else {
               // e 临时节点的作用, k 存放该当前节点的key
               Node<K,V> e; K k;
               //第一种,插入的key-value的hash值,key都与当前节点的相等,e = p,则表示为首节点
               if (p.hash == hash &&
                  ((k = p.key) == key || (key != null && key.equals(k))))
                   e = p;
               //第二种,hash值不等于首节点,判断该p是否属于红黑树的节点
               else if (p instanceof TreeNode)
                   /**为红黑树的节点,则在红黑树中进行添加,如果该节点已经存在,则返回该节点(不为null),该值很重要,用来判断put操作是否成功,如果添加成功返回null**/
                   e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
               //第三种,hash值不等于首节点,不为红黑树的节点,则为链表的节点
               else {
                   //遍历该链表
                   for (int binCount = 0; ; ++binCount) {
                       //如果找到尾部,则表明添加的key-value没有重复,在尾部进行添加
                       if ((e = p.next) == null) {
                           p.next = newNode(hash, key, value, null);
                           //判断是否要转换为红黑树结构
                           if (binCount >= TREEIFY_THRESHOLD - 1)
                               treeifyBin(tab, hash);
                           break;
                      }
                       //如果链表中有重复的key,e则为当前重复的节点,结束循环
                       if (e.hash == hash &&
                          ((k = e.key) == key || (key != null && key.equals(k))))
                           break;
                       p = e;
                  }
              }
               //有重复的key,则用待插入值进行覆盖,返回旧值。
               if (e != null) {
                   V oldValue = e.value;
                   if (!onlyIfAbsent || oldValue == null)
                       e.value = value;
                   afterNodeAccess(e);
                   return oldValue;
              }
          }
           //到了此步骤,则表明待插入的key-value是没有key的重复,因为插入成功e节点的值为null
           //修改次数+1
           ++modCount;
           //实际长度+1,判断是否大于临界值,大于则扩容
           if (++size > threshold)
               resize();
           afterNodeInsertion(evict);
           //添加成功
           return null;
      }

resize方法

 final Node<K,V>[] resize() {
       //把没插入之前的哈希数组做我诶oldTal
       Node<K,V>[] oldTab = table;
       //old的长度
       int oldCap = (oldTab == null) ? 0 : oldTab.length;
       ////取出原来数组的长度和阈值。
       int oldThr = threshold;
       //初始化new的长度和临界值
       int newCap, newThr = 0;
       //oldCap > 0 //当原来的长度大于0时,也就是说不是首次初始化,因为hashMap用的是懒加载
       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;
      }
       /**如果oldCap<0,但是已经初始化了,像把元素删除完之后的情况,那么它的临界值肯定还存在,        
          如果是首次初始化,它的临界值则为0
       **/
       else if (oldThr > 0)
           newCap = oldThr;
       //首次初始化,给与默认的值
       else {              
           newCap = DEFAULT_INITIAL_CAPACITY;
           //临界值等于容量*加载因子
           newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
      }
       //此处的if为上面标记##的补充,也就是初始化时容量小于默认值16的,此时newThr没有赋值
       if (newThr == 0) {
           //new的临界值
           float ft = (float)newCap * loadFactor;
           //判断是否new容量是否大于最大值,临界值是否大于最大值
           newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                    (int)ft : Integer.MAX_VALUE);
      }
       //把上面各种情况分析出的临界值,在此处真正进行改变,也就是容量和临界值都改变了。
       threshold = newThr;
       //表示忽略该警告
    //下面这段代码就是把原来的hashmap放进新的hashmap当中了,这里没有再调用putval方法了,不然就会由于resize的无限循环导致系统爆炸了。
       @SuppressWarnings({"rawtypes","unchecked"})
           //初始化
           Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
       //赋予当前的table
       table = newTab;
       //此处自然是把old中的元素,遍历到new中
       if (oldTab != null) {
           for (int j = 0; j < oldCap; ++j) {
               //临时变量
               Node<K,V> e;
               //当前哈希桶的位置值不为null,也就是数组下标处有值,因为有值表示可能会发生冲突
               if ((e = oldTab[j]) != null) {
                   //把已经赋值之后的变量置位null,当然是为了好回收,释放内存
                   oldTab[j] = null;
                   //如果下标处的节点没有下一个元素
                   if (e.next == null)
                       //把该变量的值存入newCap中,e.hash & (newCap - 1)并不等于j
                       newTab[e.hash & (newCap - 1)] = e;
                   //该节点为红黑树结构,也就是存在哈希冲突,该哈希桶中有多个元素
                   else if (e instanceof TreeNode)
                       //把此树进行转移到newCap中
                      ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                   else { /**此处表示为链表结构,同样把链表转移到newCap中,就是把链表遍历后,把值转过去,在置位null**/
                       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;
                      }
                  }
              }
          }
      }
       //返回扩容后的hashMap
       return newTab;
  }

remove方法

  public V remove(Object key) {
       //临时变量
       Node<K,V> e;
       /**调用removeNode(hash(key), key, null, false, true)进行删除,第三个value为null,表示,把key的节点直接都删除了,不需要用到值,如果设为值,则还需要去进行查找操作**/
       return (e = removeNode(hash(key), key, null, false, true)) == null ?
           null : e.value;
  }
   
   /**第一参数为哈希值,第二个为key,第三个value,第四个为是为true的话,则表示删除它key对应的value,不删除key,第四个如果为false,则表示删除后,不移动节点**/
   final Node<K,V> removeNode(int hash, Object key, Object value,
                              boolean matchValue, boolean movable) {
       //tab 哈希数组,p 数组下标的节点,n 长度,index 当前数组下标
       Node<K,V>[] tab; Node<K,V> p; int n, index;
       //哈希数组不为null,且长度大于0,然后获得到要删除key的节点所在是数组下标位置
       if ((tab = table) != null && (n = tab.length) > 0 &&
          (p = tab[index = (n - 1) & hash]) != null) {
           //nodee 存储要删除的节点,e 临时变量,k 当前节点的key,v 当前节点的value
           Node<K,V> node = null, e; K k; V v;
           //如果数组下标的节点正好是要删除的节点,把值赋给临时变量node
           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不再是数组下标的节点,而是要删除结点的上一个结点**/
                       p = e;
                  } while ((e = e.next) != null);
              }
          }
           //找到要删除的节点后,判断!matchValue,我们正常的remove删除,!matchValue都为true
           if (node != null && (!matchValue || (v = node.value) == value ||
                                (value != null && value.equals(v)))) {
               //如果删除的节点是红黑树结构,则去红黑树中删除
               if (node instanceof TreeNode)
                  ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
               //如果是链表结构,且删除的节点为数组下标节点,也就是头结点,直接让下一个作为头
               else if (node == p)
                   tab[index] = node.next;
               else /**为链表结构,删除的节点在链表中,把要删除的下一个结点设为上一个结点的下一个节点**/
                   p.next = node.next;
               //修改计数器
               ++modCount;
               //长度减一
               --size;
               /**此方法在hashMap中是为了让子类去实现,主要是对删除结点后的链表关系进行处理**/
               afterNodeRemoval(node);
               //返回删除的节点
               return node;
          }
      }
       //返回null则表示没有该节点,删除失败
       return null;
  }

get方法

 public V get(Object key) {
       Node<K,V> e;
       //也是调用getNode方法来完成的
       return (e = getNode(hash(key), key)) == null ? null : e.value;
  }

   final Node<K,V> getNode(int hash, Object key) {
       //first 头结点,e 临时变量,n 长度,k 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) {
           //如果是头结点,则直接返回头结点
           if (first.hash == hash &&
              ((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 { //链表节点,一样遍历链表,找到该节点并返回
                   if (e.hash == hash &&
                      ((k = e.key) == key || (key != null && key.equals(k))))
                       return e;
              } while ((e = e.next) != null);
          }
      }
       //找不到,表示不存在该节点
       return null;
  }

红黑树插入平衡调整

CASE 1:如果关注节点是 a,它的叔叔节点 d 是红色,我们就依次执行下面的操作:

将关注节点 a 的父节点 b、叔叔节点 d 的颜色都设置成黑色;

将关注节点 a 的祖父节点 c 的颜色设置成红色;

关注节点变成 a 的祖父节点 c;

跳到 CASE 2 或者 CASE 3。

技术图片

CASE 2:如果关注节点是 a,它的叔叔节点 d 是黑色,关注节点 a 是其父节点 b 的右子节点,我们就依次执行下面的操作:

关注节点变成节点 a 的父节点 b;

围绕新的关注节点b 左旋;

跳到 CASE 3。

技术图片

CASE 3:如果关注节点是 a,它的叔叔节点 d 是黑色,关注节点 a 是其父节点 b 的左子节点,我们就依次执行下面的操作:

围绕关注节点 a 的祖父节点 c 右旋;

将关注节点 a 的父节点 b、兄弟节点 c 的颜色互换。

调整结束。

技术图片

 



以上是关于hashMap 1.8的主要内容,如果未能解决你的问题,请参考以下文章

Java集合系列-HashMap 1.8

Java源码—JDK 1.8 HashMap重点源码部分剖析

hashMap 1.8

HashMap详解(基于JDK 1.8)

HashMap 1.8的源码分析二

Java深入研究9HashMap源码解析(jdk 1.8)