1.HashMap主要成员属性

/**     * The default initial capacity - MUST be a power of two.      默认的初始化容量 2的幂等次方     */    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16    /**     * The maximum capacity, used if a higher value is implicitly specified     * by either of the constructors with arguments.     * MUST be a power of two <= 1<<30.      最大的扩容容量     */    static final int MAXIMUM_CAPACITY = 1 << 30;    /**     * The load factor used when none specified in constructor.      负载因子，当容量满的时候，     */    static final float DEFAULT_LOAD_FACTOR = 0.75f;    /**     * The bin count threshold for using a tree rather than list for a     * bin.  Bins are converted to trees when adding an element to a     * bin with at least this many nodes. The value must be greater     * than 2 and should be at least 8 to mesh with assumptions in     * tree removal about conversion back to plain bins upon     * shrinkage.       链表的长度为8     */    static final int TREEIFY_THRESHOLD = 8;    /**     * The bin count threshold for untreeifying a (split) bin during a     * resize operation. Should be less than TREEIFY_THRESHOLD, and at     * most 6 to mesh with shrinkage detection under removal.        如果树的长度小于6，就恢复到链表。     */    static final int UNTREEIFY_THRESHOLD = 6;

2.Node节点

/**     * Basic hash bin node, used for most entries.  (See below for     * TreeNode subclass, and in LinkedHashMap for its Entry subclass.)     */    static class Node
   
     implements Map.Entry
    
      {        final int hash;//当前的hash值        final K key;         V value;        Node
     
       next;//下一个节点的指针        Node(int hash, K key, V value, Node
      
        next) {            this.hash = hash;            this.key = key;            this.value = value;            this.next = next;        }        public final K getKey()        { return key; }        public final V getValue()      { return value; }        public final String toString() { return key + "=" + value; }        public final int hashCode() {            return Objects.hashCode(key) ^ Objects.hashCode(value);        }        public final V setValue(V newValue) {            V oldValue = value;            value = newValue;            return oldValue;        }        public final boolean equals(Object o) {            if (o == this)                return true;            if (o instanceof Map.Entry) {                Map.Entry
        e = (Map.Entry
       )o;                if (Objects.equals(key, e.getKey()) &&                    Objects.equals(value, e.getValue()))                    return true;            }            return false;        }    }

3.JDK7 HashMap采用的是位桶和链表的，就是所谓的散列表。JDK 采用了位桶+链表/红黑树。

JDK8 put方法

JDK1.8 put方法源码：

/**     * Computes key.hashCode() and spreads (XORs) higher bits of hash     * to lower.  Because the table uses power-of-two masking, sets of     * hashes that vary only in bits above the current mask will     * always collide. (Among known examples are sets of Float keys     * holding consecutive whole numbers in small tables.)  So we     * apply a transform that spreads the impact of higher bits     * downward. There is a tradeoff between speed, utility, and     * quality of bit-spreading. Because many common sets of hashes     * are already reasonably distributed (so don't benefit from     * spreading), and because we use trees to handle large sets of     * collisions in bins, we just XOR some shifted bits in the     * cheapest possible way to reduce systematic lossage, as well as     * to incorporate impact of the highest bits that would otherwise     * never be used in index calculations because of table bounds.        把key的hashCode与key的高16位异或     */    static final int hash(Object key) {        int h;        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);    }//put方法public V put(K key, V value) {        return putVal(hash(key), key, value, false, true);    }

/**     * Implements Map.put and related methods     *     * @param hash hash for key     * @param key the key     * @param value the value to put     * @param onlyIfAbsent if true, don't change existing value     * @param evict if false, the table is in creation mode.     * @return previous value, or null if none     */    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        Node
   
    [] tab; Node
    
      p; int n, i;         //若table为null,就resize()        if ((tab = table) == null || (n = tab.length) == 0)            n = (tab = resize()).length;        if ((p = tab[i = (n - 1) & hash]) == null)//计算下标i,取出元素i处元素为p,若p为null            tab[i] = newNode(hash, key, value, null);//创建新的node节点，放入数组        else {//若p!=null            Node
     
       e; K k;            if (p.hash == hash &&                ((k = p.key) == key || (key != null && key.equals(k))))                e = p;//若key相同，直接覆盖            else if (p instanceof TreeNode)               //如果为树节点，放到TreeNode                e = ((TreeNode
      
       )p).putTreeVal(this, tab, hash, key, value);            else {//key不相同，也不是TreeNode节点              //为链表，循环遍历链表                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;    }