HashMap 源码解析

/**
     * Returns a power of two size for the given target capacity.
     * 
     */
    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;
    }

 Map map = new HashMap(11);
      map.put("1", "2");
      //获取HashMap整个类
      Class<?> mapType = map.getClass();
      //获取指定属性，也可以调用getDeclaredFields()方法获取属性数组
      Field threshold =  mapType.getDeclaredField("threshold");
      //将目标属性设置为可以访问
      threshold.setAccessible(true);
      //获取指定方法，因为HashMap没有容量这个属性，但是capacity方法会返回容量值
      Method capacity = mapType.getDeclaredMethod("capacity");
      //设置目标方法为可访问
      capacity.setAccessible(true);
      //打印刚初始化的HashMap的容量、阈值和元素数量
      System.out.println("容量："+capacity.invoke(map)+"    阈值："+threshold.get(map)+"    元素数量："+map.size());
      for (int i = 0;i<17;i++){
          map.put(i,i);
          //动态监测HashMap的容量、阈值和元素数量
          System.out.println("容量："+capacity.invoke(map)+"    阈值："+threshold.get(map)+"    元素数量："+map.size());
      }
//执行结果如下：
容量：16    阈值：12    元素数量：1
容量：16    阈值：12    元素数量：2
容量：16    阈值：12    元素数量：3
容量：16    阈值：12    元素数量：4
容量：16    阈值：12    元素数量：5
容量：16    阈值：12    元素数量：6
容量：16    阈值：12    元素数量：7
容量：16    阈值：12    元素数量：8
容量：16    阈值：12    元素数量：9
容量：16    阈值：12    元素数量：10
容量：16    阈值：12    元素数量：11
容量：16    阈值：12    元素数量：12
容量：32    阈值：24    元素数量：13
容量：32    阈值：24    元素数量：14
容量：32    阈值：24    元素数量：15
容量：32    阈值：24    元素数量：16
容量：32    阈值：24    元素数量：17
容量：32    阈值：24    元素数量：18

//JDK1.8HashMap的hash()源码
//不是单纯的做了一下hash而是做了位运算
 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

public V put(K key, V value) {
    //调用putVal()方法完成
    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;
    //判断table是否初始化，否则初始化操作
    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;
        //节点若已经存在，执行赋值操作
        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;
                }
                //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;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    //记录修改次数
    ++modCount;
    //判断是否需要扩容
    if (++size > threshold)
        resize();
    //空操作
    afterNodeInsertion(evict);
    return null;
}