平时工作中，hashMap都会被用到，面试过程中也会被问到，今天就来浅浅的了解一下hashMap

1.HashMap的常量

先来看一下hashMap中比较重要的几个常量

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//默认初始容量16,必须为2的幂

static final int MAXIMUM_CAPACITY = 1 << 30 //2的30次幂

static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认负载因子

static final int TREEIFY_THRESHOLD = 8;//树化阈值

static final int UNTREEIFY_THRESHOLD = 6;//链表化阈值(退化成链表的值)

static final int MIN_TREEIFY_CAPACITY = 64;//最小树化容量

2.2个重要的方法

2.1 hash方法

static final int hash(Object key) {
        int h;
	//如果key为null，则返回0
	//key不为null，则取key的hashCode值h，并将h与h右移16位的值异或
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }

h右移16位之后前16位补0，0与x异或等于x，所以异或出来的值hash前16位等于key的hashCode的值的前16位，hash的后16位则是h的前16位和后16位的混合，同时保证了h的高16位和低16位的特征，减少了hash碰撞

2.2 tableSizeFor方法

static final int tableSizeFor(int cap) {
       int n = cap - 1;
       n |= n >>> 1;
       n |= n >>> 2;
       n |= n >>> 4;
       n |= n >>> 8;
       n |= n >>> 16;
       return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
   }

cap是一个大于0的数，n=cap - 1就是一个大于等于0的数，这个方法就是将最高有效位1后面的位数全变成1.例如8，二进制是0000 1000，进行一次运算后变成0000 1100，二次运算变成0000 1111，这样就找出了比cap大的最近的2的幂次方的数

3.构造函数

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

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

public HashMap() {
  this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

public HashMap(Map<? extends K, ? extends V> m) {
  this.loadFactor = DEFAULT_LOAD_FACTOR;
  putMapEntries(m, false);
}

4.put方法详解

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
  //定义变量tab，p，n，i
  Node<K,V>[] tab; 
  Node<K,V> p; 
  int n, i;
  //1.如果集合为空(第一次使用)，初始化用默认值
  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 {
    //如果要插入的位置有元素，分为三种情况
    Node<K,V> e; K k;
    //1.如果key相同，则覆盖原来的key
    if (p.hash == hash &&
        ((k = p.key) == key || (key != null && key.equals(k))))
      e = p;
    //2.如果此位置元素是红黑树节点，则将节点插入树中
    else if (p instanceof TreeNode)
      e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
    //3.如果不是红黑树节点，key也不同，则将此节点放到这个链表的最后，如果链表长度大于等于8，则树化
    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
            treeifyBin(tab, hash);
          break;
        }
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
          break;
        p = e;
      }
    }
    //如果相同key的value被覆盖，则返回覆盖前的值
    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;
    }

底层原理：如果使用无参构造，第一次put时，会发生扩容，应用初始容量为16，初始负载因子为0.75，初始扩容阈值为12，此时是先扩容再插入数据。当不是第一次put时，计算待插入的元素要插入的位置

i = (n - 1) & hash//n为容量

如果此位置没有元素，直接插入；如果此位置有元素，分为三种情况：

• 如果key相同，则覆盖原来的value，并返回被覆盖的value值
• 如果此位置元素是红黑树的根节点，则将节点插入树中
• 如果此位置元素就是红黑树的根节点，key也不相同，则将此元素插入链表的末尾，如果链表长度大于8，则树化。

5.扩容机制详解

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;
    }
    //如果旧数组容量变为两倍后并且原数组容量大于16，数组容量和阈值都变为两倍
    else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
             oldCap >= DEFAULT_INITIAL_CAPACITY)
      newThr = oldThr << 1; // double threshold
  }
  //如果构造函数是指定初始容量为0，负载因子大于0的构造函数
  //会将扩容后的数组容量变为1，阈值变为0
  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;
            //判断新数组的位置是原数组相同的位置还是原数组的位置加上原数组的容量
            //1.举例，如果原数组容量是8，那么此元素原数组的位置是hash&0111,只有hash的值
            //后三位起作用，此处hash&1000,就是判断从右往左第四位是1还是0，如果是0，
            //那么与运算16,还是后三位起作用，位置不变，如果是1，那么与运算16，就变成原位置+8.
            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);//此处while循环是为了将整个链表都拷贝过去
          if (loTail != null) {
            loTail.next = null;
            newTab[j] = loHead;
          }
          if (hiTail != null) {
            hiTail.next = null;
            newTab[j + oldCap] = hiHead;
          }
        }
      }
    }
  }
  return newTab;
    }

原理：如果原数组容量大于容量最大值，则返回；如果就数组容量变为两倍后小于最大容量，并且原数组容量大于16，则新数组容量和阈值都变为两倍；扩容时，遍历旧数组，如果遍历到的下标位置上只有一个元素，直接计算新的元素下标，并插入到新数组中；如果是红黑树节点，则需要拆分树；如果是链表，则链表上的每一个元素的新下标要么是原下标，要么是原下标加上旧数组的容量。

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
  TreeNode<K,V> b = this;
  // Relink into lo and hi lists, preserving order
  //定义不需要更换下标的头结点loHead，尾结点loTail
//定义需要更换下标的头节点hiHead,尾结点hiTail
  TreeNode<K,V> loHead = null, loTail = null;
  TreeNode<K,V> hiHead = null, hiTail = null;
  int lc = 0, hc = 0;
  for (TreeNode<K,V> e = b, next; e != null; e = next) {
    next = (TreeNode<K,V>)e.next;
    e.next = null;
    //判断此节点是否需要更换下标
    if ((e.hash & bit) == 0) {
      if ((e.prev = loTail) == null)
        loHead = e;
      else
        loTail.next = e;
      loTail = e;
      ++lc;
    }
    else {
      if ((e.prev = hiTail) == null)
        hiHead = e;
      else
        hiTail.next = e;
      hiTail = e;
      ++hc;
    }
  }
  
  if (loHead != null) {
    //不需要更换位置的节点链表如果长度小于6，则退化成链表
    if (lc <= UNTREEIFY_THRESHOLD)
      tab[index] = loHead.untreeify(map);
    else {
      //否则新的链表节点树化
      tab[index] = loHead;
      if (hiHead != null) // (else is already treeified)
        loHead.treeify(tab);
    }
  }
  if (hiHead != null) {
    //需要更换位置的节点链表如果长度小于6，则退化成链表
    if (hc <= UNTREEIFY_THRESHOLD)
      tab[index + bit] = hiHead.untreeify(map);
    else {
      //否则新的节点链表树化
      tab[index + bit] = hiHead;
      if (loHead != null)
        hiHead.treeify(tab);
    }
  }
        }

拆分树时，树上的每一个节点新下标，要么是原下标，要么是原下标+旧数组的容量。两种新下标各自成链表后，看链表长度是否小于6，如果小于6就退化成链表，如果不小于6就树化。

6.树化逻辑

final void treeifyBin(Node<K,V>[] tab, int hash) {
 int n, index; Node<K,V> e;
 //如果集合的容量小于64，则扩容
 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
   resize();
 else if ((e = tab[index = (n - 1) & hash]) != null) {
   //将节点转为树节点，并按照链表的顺序(put的顺序串起来)，
   //TreeNode既是红黑树结构，也是双链表结构
   TreeNode<K,V> hd = null, tl = null;
   do {
     TreeNode<K,V> p = replacementTreeNode(e, null);
     if (tl == null)
       hd = p;
     else {
       p.prev = tl;
       tl.next = p;
     }
     tl = p;
   } while ((e = e.next) != null);
   if ((tab[index] = hd) != null)
     //树化逻辑
     hd.treeify(tab);
 }
   }

final void treeify(Node<K,V>[] tab) {
 TreeNode<K,V> root = null;
 for (TreeNode<K,V> x = this, next; x != null; x = next) {
   next = (TreeNode<K,V>)x.next;
   x.left = x.right = null;
   if (root == null) {
     x.parent = null;
     x.red = false;
     root = x;
   }
   else {
     K k = x.key;
     int h = x.hash;
     Class<?> kc = null;
     for (TreeNode<K,V> p = root;;) {
       int dir, ph;
       K pk = p.key;
       if ((ph = p.hash) > h)
         dir = -1;
       else if (ph < h)
         dir = 1;
       else if ((kc == null &&
                 (kc = comparableClassFor(k)) == null) ||
                (dir = compareComparables(kc, k, pk)) == 0)
         dir = tieBreakOrder(k, pk);
       
       TreeNode<K,V> xp = p;
       if ((p = (dir <= 0) ? p.left : p.right) == null) {
         x.parent = xp;
         if (dir <= 0)
           xp.left = x;
         else
           xp.right = x;
         root = balanceInsertion(root, x);
         break;
       }
     }
   }
 }
 //将红黑树的root节点变成整个链表的头节点
 moveRootToFront(tab, root);
}

原理：树化逻辑是这样：按照双链表的顺序一个一个遍历树节点，形成一个红黑树，具体方法是比较他们的hash值，通过左旋和右旋以及变色来形成红黑树，并满足红黑树的特点

• 每个节点要么是黑色，要么是红色
• 根节点是黑色
• 每个叶子节点(为空的叶子节点)是黑色
• 每个红色节点的两个子节点一定都是黑色
• 任意一节点到每个叶子节点的路径都包含数量相同的黑节点

static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
            int n;
            if (root != null && tab != null && (n = tab.length) > 0) {
                //获取元素位置
                int index = (n - 1) & root.hash;
                //获取原先的头元素
                TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
                if (root != first) {
                    //如果树化后的节点和原头元素不相等，取出链表中的root元素
                    Node<K,V> rn;
                    tab[index] = root;
                    TreeNode<K,V> rp = root.prev;
                    if ((rn = root.next) != null)
                        ((TreeNode<K,V>)rn).prev = rp;
                    if (rp != null)
                        rp.next = rn;
                    //将root放到头节点的位置
                    if (first != null)
                        first.prev = root;
                    root.next = first;
                    root.prev = null;
                }
                assert checkInvariants(root);
            }
        }

TreeNode<K,V> parent;  // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev;    // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
  super(hash, key, val, next);
}

TreeNode可以被看做红黑树节点是因为它的left属性和right属性以及red属性，可以被看做链表是因为他的prev属性和父类的next属性

7.获取元素值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) {
    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 {
        if (e.hash == hash &&
            ((k = e.key) == key || (key != null && key.equals(k))))
          return e;
      } while ((e = e.next) != null);
    }
  }
  return null;
    }

final TreeNode<K,V> getTreeNode(int h, Object k) {
  //如果不是根节点，找这棵树的根节点，如果是根节点，根据hash值找对应的元素
  return ((parent != null) ? root() : this).find(h, k, null);
        }

final TreeNode<K,V> root() {
  for (TreeNode<K,V> r = this, p;;) {
    if ((p = r.parent) == null)
      return r;
    r = p;
  }
        }

查找根节点的逻辑就是一直循环找父节点，直到父节点为空

final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
  TreeNode<K,V> p = this;
  do {
    int ph, dir; K pk;
    TreeNode<K,V> pl = p.left, pr = p.right, q;
    if ((ph = p.hash) > h)
      p = pl;
    else if (ph < h)
      p = pr;
    else if ((pk = p.key) == k || (k != null && k.equals(pk)))
      return p;
    else if (pl == null)
      p = pr;
    else if (pr == null)
      p = pl;
    else if ((kc != null ||
              (kc = comparableClassFor(k)) != null) &&
             (dir = compareComparables(kc, k, pk)) != 0)
      p = (dir < 0) ? pl : pr;
    else if ((q = pr.find(h, k, kc)) != null)
      return q;
    else
      p = pl;
  } while (p != null);
  return null;
        }

找到根节点之后，根据hash值在树上找对应的元素，返回

8.删除元素详解

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) {
    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 = e;
        } while ((e = e.next) != null);
      }
    }
    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
        //如果不是树节点，并且要删除的元素不是头节点，
        //将要删除的元素的前一个元素的next指向要删除的元素的下一个元素
        p.next = node.next;
      ++modCount;
      --size;
      afterNodeRemoval(node);
      return node;
    }
  }
  //找不到要删除的元素，直接返回空
  return null;
    }

get和remove的逻辑相对简单，看看注释就好

总结

• 链表的树化有两个条件，链表长度大于8，数组容量大于等于64
• 红黑树退化成链表有两种情况：
  • 在扩容时拆分树的时候，树元素个数小于等于6会退化成链表
  • 删除树节点时，若根节点root、root.left、root.right、root.left.left中有一个为空，也会退化成链表