hashmap的存放元素的实现过程

1.代码实现

 // 存放运算的方法，hash(key)即获取key的hash码值，算法为(key.hashcode())^(key.hashcode()>>>16),前面有分析
  public V put(K key, V value) {
      return putVal(hash(key), key, value, false, true);
  }

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)
    	// resize()扩容过程前面有分析
        n = (tab = resize()).length;
    // 用hash和数组长度减一做与运算确定元素插入位置，如果该位置没有元素则创建一个结点放在那里
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
    	// 如果有元素则走此
        Node<K,V> e; K k;
        // 判断此位置元素的hash值与键值key是否相等，相等则替换value
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
        	// 判断p是否是红黑树结点，是将该值插入到红黑树中
            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;
                }
                // 在遍历链表的过程中发现hash和key 相同则直接替换掉该值
                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;
            // onlyIfAbsent 如果存在该值是否替换，false为替换，true表示不替换，默认为false
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            // 该方法空实现，不用管
            afterNodeAccess(e);
            return oldValue;
        }
    }
    // modCount记录的是修改次数，不用管
    ++modCount;
    // 如果数组使用大于阀值，扩容
    if (++size > threshold)
    	// 扩容方法
        resize();
     // 空实现，不用管
    afterNodeInsertion(evict);
    return null;
}

// 该方法可以参考前面分析的treeify方法，实现过程基本一样
 final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                                int h, K k, V v) {
     Class<?> kc = null;
     boolean searched = false;
     TreeNode<K,V> root = (parent != null) ? root() : this;
     for (TreeNode<K,V> p = root;;) {
         int dir, ph; K pk;
         if ((ph = p.hash) > h)
             dir = -1;
         else if (ph < h)
             dir = 1;
         else if ((pk = p.key) == k || (k != null && k.equals(pk)))
             return p;
         else if ((kc == null &&
                   (kc = comparableClassFor(k)) == null) ||
                  (dir = compareComparables(kc, k, pk)) == 0) {
             if (!searched) {
                 TreeNode<K,V> q, ch;
                 searched = true;
                 if (((ch = p.left) != null &&
                      (q = ch.find(h, k, kc)) != null) ||
                     ((ch = p.right) != null &&
                      (q = ch.find(h, k, kc)) != null))
                     return q;
             }
             dir = tieBreakOrder(k, pk);
         }

         TreeNode<K,V> xp = p;
         if ((p = (dir <= 0) ? p.left : p.right) == null) {
             Node<K,V> xpn = xp.next;
             TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
             if (dir <= 0)
                 xp.left = x;
             else
                 xp.right = x;
             xp.next = x;
             x.parent = x.prev = xp;
             if (xpn != null)
                 ((TreeNode<K,V>)xpn).prev = x;
             moveRootToFront(tab, balanceInsertion(root, x));
             return null;
         }
     }
 }

2.总结

实现过程分为以下几步

1. 判断数组是否为空或数组长度是否为空,没有立马扩容
2. 确定插入元素在数组的位置，算法是hash&(cap -1)
3. 如果该位置没有存放元素，直接将该元素存在在此
4. 如果该位置是红黑树，则会遍历红黑树去看是否有相同值，有则返回该节点,没有则会插入到红黑树中
5. 如果该位置是链表，则会遍历链表查看是否有相同值，有则返回该节点，没有会将元素插入到链表末尾，并判断节点达到8了没，达到则进行树化
6. 如果有相同值则进行替换，修改次数加1，并判断是否需要扩容，需要则扩容

3.其他关于hashmap的分析

hashmap的常见静态属性和方法
hashmap的扩容机制
hashmap链表转化成红黑树的过程以及红黑树转化成链表的过程