HashMap

在进行HashMap源码之前先稍微了解下位运算的基本操作。

位运算

'&'相同位的两个数字都为1，则为1；若有一个不为1，则为0。

将10与-10进行按位与(&)运算：
0000 0000 0000 1010
1111 1111 1111 0110
-----------------------
0000 0000 0000 0010
所以：10 & -10 = 0000 0000 0000 0010

‘|’ 相同位只要一个为1即为1。

将10与-10进行按位或(|)运算：
0000 0000 0000 1010
1111 1111 1111 0110
-----------------------
1111 1111 1111 1110
所以：10 | -10 = 1111 1111 1111 1110

补码 先按正数转换，然后取反加1

要将十进制的-10用二进制表示，先将10用二进制表示：
0000 0000 0000 1010
取反：
1111 1111 1111 0101
加1：
1111 1111 1111 0110
所以，-10的二进制表示就是：1111 1111 1111 0110

按位异或(^) 只有当相应位上的数字不相同时，该为才取1，若相同，即为0。

将10与-10进行按位异或(^)运算：
0000 0000 0000 1010
1111 1111 1111 0110
-----------------------
1111 1111 1111 1100
所以：10 ^ -10 = 1111 1111 1111 1100

取反(~) 每个位上都取相反值，1变成0，0变成1

对10进行取反(~)运算：
0000 0000 0000 1010
---------------------
1111 1111 1111 0101
所以：~10 = 1111 1111 1111 0101

左移(<<) 用来将一个数各二进制位全部向左移动若干位。

对10左移2位(就相当于在右边加2个0)：
0000 0000 0000 1010
--------------------
0000 0000 0010 1000
所以：10 << 2 = 0000 0000 0010 1000 = 40

右移(>>) 进行右移运算，用来将一个数各二进制位全部向右移动若干位。

对10右移2位(就相当于在左边加2个0)：
0000 0000 0000 1010
--------------------
0000 0000 0000 0010
所以：10 >> 2 = 0000 0000 0000 0010 = 2

无符号右移涉及到高位的符号问题（无符号左移<<<和左移<<是一样的概念）
按照操作数右侧所指定的位数将操作数的二进制位向右移动，不管其原数正负，最高位统一补0，低位移出（舍弃）

HashMap

• 介绍
  数组+链表，基于哈希表的 Map 接口的实现，以key-value的形式存在，
  多线程情况下，在rehash，重新计算hash,put形成闭环链表，在get的情况不断循环造成cpu100%

• 原理
  
  包含Java7-Java8的红黑树改进
  获取

     public V get(Object key) {
          if (key == null)
              return getForNullKey();
          int hash = hash(key.hashCode());//通过key进行hash计算，以便均匀分散到数组上
          // 取hash上的链表Entry，并循环比较链表Entry的key是否是需要的数据
          for (Entry<K,V> e = table[indexFor(hash, table.length)];
               e != null;
               e = e.next) {
               Object k;
               if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                  return e.value;
          }
          return null;
      }
  

  插入

  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
      boolean evict) {
          // hashMap所有链表数组； 要插入的链表； 所有链表长度
          Node<K,V>[] tab; Node<K,V> p; int n, i;
          //1、获取数组的长度
          //2、p判断插入的位置是否是存在值的，如果不存在值就直接newNode，hash数组均匀分散
          if ((tab = table) == null || (n = tab.length) == 0)
              n = (tab = resize()).length;
          if ((p = tab[i = (n - 1) & hash]) == null)//保证下标不会越界，下标位置空直接使用
              tab[i] = newNode(hash, key, value, null);
          else {
              // 这边的p是已存在的链表节点
              // e: 指向put操作的在p链表上的具体节点  k:key值
              Node<K,V> e; K k;
              // 是否与插入的key一样，若相同那就直接使用插入的值p替换掉
              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);
                          // 判断当前链表的长度是否大于阈值8，如果大于那就会把当前链表转变成红黑树
                          if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                              treeifyBin(tab, hash);
                          break;
                      }
                      if (e.hash == hash &&
                              ((k = e.key) == key || (key != null && key.equals(k))))
                          break;
                      p = e;
                  }
              }
              if (e != null) { // existing mapping for key
                  V oldValue = e.value;
                  if (!onlyIfAbsent || oldValue == null)
                      e.value = value;
                  afterNodeAccess(e);
                  return oldValue;
              }
          }
          ++modCount;
          // 扩容
          if (++size > threshold)
              resize();
          afterNodeInsertion(evict);
          return null;
      }
      
  

  扩容

  final Node<K,V>[] resize() {
      Node<K,V>[] oldTab = table;
      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;//阈值、扩容数值end
      
      //第三部分：旧数据保存在新数组里面
      @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;
                          /*table中的元素只有两种情况：
                          元素hash值第N+1位为0：不需要进行位置调整
                          元素hash值第N+1位为1：调整至原索引的两倍位置*/
                          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);
                      
                      //链表1存于原索引
                      if (loTail != null) {
                          loTail.next = null;
                          newTab[j] = loHead;
                      }
                      //链表2存于原索引加上原hash桶长度的偏移量
                      if (hiTail != null) {
                          hiTail.next = null;
                          newTab[j + oldCap] = hiHead;
                      }
                  }
              }
          }
      }
      return newTab;
  }  
  
  

  
  
  

• 案例