private static final long serialVersionUID = 362498820763181265L;

     //The default initial capacity - MUST be a power of two.

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //jdk1.6直接寫16，這效率更快？？

     // The maximum capacity,MUST be a power of two <= 1<<30.

static final 

static final float DEFAULT_LOAD_FACTOR = 0.75f; //填充比，裝載因子

/**（jdk1.8新加）

* The bin count threshold for using a tree rather than list for a

     * bin.當add一個元素到某個位桶，其連結串列長度達到8時將連結串列轉換為紅黑樹.

     * 2< value<=8 時to mesh with assumptions in  

     *連結串列轉為樹，binCount>=TREEIFY_THRESHOLD-1，-1 for 1st。

     */ //當某個桶中的鍵值對數量大於8個【9個起】，且桶數量大於等於64，則將底層實現從連結串列轉為紅黑樹

static final int TREEIFY_THRESHOLD= 8; //jdk1.8新加

static final int UNTREEIFY_THRESHOLD = 6;//jdk1.8新加

static final int MIN_TREEIFY_CAPACITY = 64;//jdk1.8新加

/* ---------------- Fields -------------- */

    // jdk1.6 為 transient Entry[] table;

transient Node<K,V>[] table; //儲存元素(位桶)的陣列,length power of two

transient Set<Map.Entry<K,V>> entrySet;

transient int size; // key-value對，實際容量

transient int modCount; //結構改變次數，fast-fail機制

int threshold; // 新的擴容resize臨界值,當實際大小(容量*填充比)大於臨界值時，會進行2倍擴容

final float loadFactor;

Node 內部類

是HashMap內部類（jdk1.6就是Entry），繼承自 Map.Entry這個內部介面，它就是儲存一對對映關係的最小單元，也就是說key，value實際儲存在Node中。與1.6相比，修改了 hashCode()、equals()方法【直接呼叫Object的hashCode、equals方法，而不是copy程式碼過來】，去掉了toString()、recordAccess(HashMap<K,V> m)【the value in an entry is overwritten時呼叫】、recordRemoval(HashMap<K,V> m)【remove entry時呼叫】方法。【鍵值對】

static class Node<K,V>implements Map.Entry<K,V> {
        final int hash; //結點的雜湊值，不可變
        final K key;
        V value;
        Node<K,V> next; //指向下一個節點
 
        Node(int hash, K key, V value, Node<K,V> 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; }
      // 由直接實現 變為 呼叫Object的HashCode，實際是一樣的
        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        } //按位異或^不同為真,數a兩次異或同一個數b(a=a^b^b)仍然為原值a。
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            returnoldValue;
        }  // 優化邏輯
        public final boolean equals(Object o) {//改為呼叫Object的equals
            if (o == this) //記憶體地址(1.8新增)
                return true;
            if (o instanceof Map.Entry) {//1.6中!(instanceof)返回false
                Map.Entry<?,?> e = (Map.Entry<?,?>)o; //新加<?,?>泛型
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }
/*  jdk 1.6 Entry 的equals方法
public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        } */

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        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; //true表示紅節點，false表示黑節點
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
        }
        /**
         * Returns root of tree containing this node.獲取紅黑樹的根
         */
        final TreeNode<K,V> root() { 
           for (TreeNode<K,V> r=this, p;;){//p定義,int a=1,b;不能直接輸出b(未初始化)
                if ((p = r.parent) == null)  //若改為類似並查集的路徑壓縮（結構改變）
                    return r;
                r = p;
            }
        }
        /**
         * Ensures that the given root is the first node of its bin.
         */ //確保root是桶中的第一個元素，將root移到桶中的第一個【平衡思想】
        static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {}
        /**
         * Finds the node starting at root p with the given hash and key.
         * The kc argument caches comparableClassFor(key) upon first use
         * comparing keys.
         *///查詢hash為h，key為k的節點  
        final TreeNode<K,V> find(int h, Object k, Class<?> kc) { // 詳見get相關
              TreeNode<K,V> p = this;   ……   }
        /**
         * Calls find for root node.
         */ //獲取樹節點，通過根節點查詢 
        final TreeNode<K,V> getTreeNode(int h, Object k) { // 詳見get相關
            return ((parent != null) ? root() : this).find(h, k, null);
        }
        /**
         * Tie-breaking utility for ordering insertions when equal
         * hashCodes and non-comparable. We don't require a total
         * order, just a consistent insertion rule to maintain
         * equivalence across rebalancings. Tie-breaking further than
         * necessary simplifies testing a bit.
         */ //比較2個物件的大小 
        static int tieBreakOrder(Object a, Object b) {}
        /**
         * Forms tree of the nodes linked from this node.
         * @return root of tree
         */ //將連結串列轉為二叉樹
        finalvoid treeify(Node<K,V>[] tab) {} //根節點設定為黑色 
        /**
         * Returns a list of non-TreeNodes replacing those linked from
         * this node.
         */ //將二叉樹轉為連結串列 
        final Node<K,V> untreeify(HashMap<K,V> map) {}
        /**
         * Tree version of putVal.
         */ //新增一個鍵值對 
        final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
                                       inth, K k, V v) {}
        /**
         * Removes the given node, that must be present before this call.
         * This is messier than typical red-black deletion code because we
         * cannot swap the contents of an interior node with a leaf
         * successor that is pinned by "next" pointers that are accessible
         * independently during traversal. So instead we swap the tree
         * linkages. If the current tree appears to have too few nodes,
         * the bin is converted back to a plain bin. (The test triggers
         * somewhere between 2 and 6 nodes, depending on tree structure).
         */
        final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
                                  boolean movable) {}
        /**
         * Splits nodes in a tree bin into lower and upper tree bins,
         * or untreeifies if now too small. Called only from resize;
         * see above discussion about split bits and indices.
         *
         * @param map the map
         * @param tab the table for recording bin heads
         * @param index the index of the table being split
         * @param bit the bit of hash to split on
         */ //將結點太多的桶分割  
        finalvoid split(HashMap<K,V> map, Node<K,V>[] tab, intindex, intbit) {}
        /* --------------------------------------------------*/
        // Red-black tree methods, all adapted from CLR
        //左旋轉
        static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
                                              TreeNode<K,V> p) {}
        //右旋轉
        static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
                                               TreeNode<K,V> p) {}
         //保證插入後平衡，共5種插入情況
        static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
                                                    TreeNode<K,V> x) {}
         //刪除後調整平衡 ，共6種刪除情況
        static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root,
                                                   TreeNode<K,V> x) {}
        /**
         * Recursive invariant check
         */ //檢測是否符合紅黑樹 
        static <K,V> boolean checkInvariants(TreeNode<K,V> t) {}
}