1.HashMap的一些重要成員屬性

      1.1) 預設的初始容量 DEFAULT_INITIAL_CAPACITY = 1 << 4，官方建議必須時2的次方數

      1.2) 負載因子DEFAULT_LOAD_FACTOR = 0.75f; 用來HashMap擴容判斷

      1.3) Node<K,V>[] table; ---容器中的元素

2.HashMap的構造方法

      1.1) 無參建構函式

      1.2) 帶容量的有參建構函式

      1.3) 帶容量和負載因子的有參建構函式

3.HashMap的hash方法

     3.1) step1: 獲取到 key的hashcode值

     3.2) step2: 將step1計算得到的值無符號右移16位

     3.3) step3: 將 step1 和 step2 的結果異或運算得到結果

4.HashMap容器中的重要元素類Node的組成

    4.1) hash值

    4.2) key 和 value值

    4.3) hash值相同時，變成連結串列結果的下一個Node

    static class Node<K,V>{
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        public Node(int hash, K key, V value, Node<K, V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        @Override
        public String toString() {
            return key + " = " + value;
        }
        //設定成新值，返回舊值
        public final V setValue(V newValue) {
            V oldValue = value;
            this.value = newValue;
            return oldValue;
        }

        @Override
        public int hashCode() {
            return Objects.hash(key) ^ Objects.hash(value);
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Node<?, ?> node = (Node<?, ?>) o;
            return Objects.equals(key, node.key) &&
                    Objects.equals(value, node.value);
        }
    }
 

5.HashMap的put方法

     5.1) 計算出HashMap中陣列所在的下標值---步驟3的hash值 和 HashMap容量的值減去1做與運算

            從上面的表格可以看出容量的大小，必須為2的次方數，不然最終陣列會有下標遺漏 

    5.2) HashMap容器put方法的返回值是舊值

    5.3) HashMap擴容時，在進行元素的重新分配時，針對單向連結串列需要明確以下節點

           5.3.1) 在同一個連結串列中，則說明這個連結串列中所有元素的hash值是相同的

          5.3.2) HashMap擴容標準是2的次方數，從4->8->16....

          5.3.3) 從5.1)可以得知hash值二進位制在舊的容量所在二進位制所處的位置是0 還是1 ，即可計算出當前整個連結串列

在新的HashMap容器中所處的位置

    public V put(K key, V value) {
        return putVal(hash(key), key, value);
    }

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    private V putVal(int hash, K key, V value) {
        //定義一個臨時變數用來儲存HashMap容器的容量大小
        int capacity;
        //定義一個新元素在HashMap中數組裡面的下表位置
        int currentIndex;

        //把HashMap容器的元素賦值給一個臨時變數
        Node<K, V>[] tempTable = table;
        //如果HashMap容器為空或者容量為0，則需要擴容
        if (tempTable == null || tempTable.length == 0) {
            tempTable = resize();
        }
        capacity = tempTable.length;
        //計算新增的值將要儲存的位置
        currentIndex = (capacity - 1) & hash;
        //從HashMap中取出當前位置的元素
        Node<K, V> tempNode = tempTable[currentIndex];
        //如果HashMap容器的當前位置還沒有儲存元素
        //則直接把信元素賦值到這個位置即可
        if (tempNode == null) {
            tempTable[currentIndex] = new Node<>(hash, key, value, null);
        } else {
            Node<K, V> modifyNode = null;
            //如果當前位置已經儲存了元素，則需要根據不同的情況來處理這個元素
            Node<K, V> currentNode = tempNode;
            //1.如果新增的元素的hash(key)相同,並且（key 的物件 和 當前物件 相等 || key!=null && key值和當前的key相等），
            // 則需要更新當前節點的值
            //2.如果當前節點的型別是紅黑樹，則進入紅黑樹的邏輯進行處理--這裡不做說明
            //3.進入單線連結串列的迴圈處理，如果在連結串列中找到和新增的元素的hash(key),key值和當前節點的都相同，並且key！= null的節點
            //只需把這個節點的值更新即可，否則直接新增到連結串列的末尾
            K currentKey = currentNode.key;
            int currentHash = currentNode.hash;
            if (currentHash == hash && (currentKey == key || key != null && key.equals(currentKey))) {
                modifyNode = currentNode;
            } else if (currentNode instanceof TreeNode) {
                //TODO jdk1.8後才有的
            } else {
                for (int bitCount = 0; ; bitCount++) {
                    Node<K, V> nextNode = currentNode.next;
                    //如果當前節點的下一個節點為null，則到了單向連結串列的尾節點
                    //直接把新元素新增到單向連結串列的結尾即可
                    if (nextNode == null) {
                        nextNode.next = new Node<>(hash, key, value, null);
                        if (bitCount >= TREEIFY_THRESHOLD - 1) {
                            //TODO 如果單向連結串列的元素個數大於所設定的向紅黑樹轉變的條件，則需要處理
                        }
                        break;
                    }
                    //如果當前節點的下一個節點不為null，則判斷新節點和當前節點是否滿足相同節點的條件
                    if (nextNode.hash == hash && (nextNode.key == key || key != null && key.equals(nextNode.key))) {
                        modifyNode = nextNode;
                        break;
                    }
                    //如果沒有遍歷到單向連結串列的末尾，並且新節點不是當前節點
                    //則繼續遍歷
                    currentNode = nextNode;
                }
            }

            //如果在單向連結串列中存在節點和新節點相同的條件，則只需要把舊節點的資料修改成新的值即可
            if (modifyNode != null) {
                V oldValue = modifyNode.value;
                //TODO 如果有引數設定，節點已經存在，切節點的值不為null就不在新增，則不需要更新節點的值
                modifyNode.value = value;
                return oldValue;
            }

        }

        size++;
        //如果容器中元素的個數大於
        // HashMap容器根據負載因子設定的閾值
        // 則需要擴容，並重新分配HashMap中元素的位置
        if (size > threshold) {
            resize();
        }
        return null;
    }

    /**
     * 初始化HashMap容器，或者重新分配HashMap容器中元素的位置
     * 因為當HashMap容器中元素超過一定的數量，需要擴容，
     * 而擴容之後元素hash值發生變化，所以需要重新分配HashMap容器中元素的位置
     */
    final Node<K, V>[] resize() {
        //定義一個臨時變數儲存舊的HashMap容器中的元素集合
        Node<K, V>[] oldTable = table;
        //舊HashMap容器的容量大小為
        int oldCapacity = oldTable == null ? 0 : oldTable.length;
        //舊的擴容標準
        int oldThreshold = threshold;
        //定義臨時變數儲存新容器容量和新擴容標準
        int newCapactity = 0;
        int newThreshold = 0;
        //如果舊的HashMap容器大於0
        if (oldCapacity > 0) {
            //如果舊的HashMap容器已經達到HashMap允許的最大容量
            //則只需把擴容標準放大到最大即可
            if (oldCapacity >= MAXIMUM_CAPACITY) {
                threshold = MAXIMUM_CAPACITY;
                return oldTable;
            }
            //如果舊的HashMap容器還沒有達到HashMap允許的最大容量
            //則把舊的容量擴大兩倍作為新的容器的容量
            newCapactity = oldCapacity << 1;
            //如果擴大後的容器容量小於HashMap允許的最大容量
            //並且大於等於預設的最小初始容量
            //則把舊的擴容標準加倍
            if (newCapactity < MAXIMUM_CAPACITY && newCapactity >= DEFAULT_INITIAL_CAPACITY) {
                newThreshold = oldThreshold << 1;
            }
        }
        //如果舊的擴容標準大於0
        else if (oldThreshold > 0) {
            newCapactity = oldThreshold;
        } else {
            // 如果上面兩個條件都不滿足，則取HashMap容器預設的標準
            newCapactity = DEFAULT_INITIAL_CAPACITY;
            newThreshold = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        threshold = newThreshold;
        //使用新的容量建立HashMap容器
        Node<K, V>[] newTable = (Node<K, V>[]) new Node[newCapactity];
        //將新HashMap容器賦值給HashMap容器
        table = newTable;
        //如果舊的HashMap容器不為空，則需要重新分配HashMap容器中的元素
        if (oldTable != null) {
            for (int i = 0; i < oldCapacity; i++) {
                Node<K, V> currentNode = oldTable[i];
                //舊HashMap容器當前位置不為空，則需要根據新的容量重新計算該元素應該存放的位置
                if (currentNode != null) {
                    oldTable[i] = null;//為了讓GC回收
                    //判斷當前節點是否有下下一個節點，如果沒有，則直接進行元素位置的重新計算
                    if (currentNode.next == null) {
                        int currentHash = currentNode.hash;
                        int newIndex = currentHash & (newCapactity - 1);
                        newTable[newIndex] = currentNode;
                    } else if (currentNode instanceof TreeNode) {
                        //TODO 如果當前節點的型別是紅黑樹
                    } else {
                        //同一個單向連結串列中元素的hash值是相等的
                        //因此在新的HashMap容器中，這個連結串列中所有的元素，
                        // 也還是在相同的位置，並且是連結串列的格式儲存
                        Node<K, V> highHeadNode = null;
                        Node<K, V> highTailNode = null;
                        Node<K, V> lowHeadNode = null;
                        Node<K, V> lowTailNode = null;
                        do {
                            int currentHash = currentNode.hash;
                            int hashLocation = currentHash & oldCapacity;
                            if (hashLocation == 0){
                                //如果尾部節點還沒有設定，則說明此時還沒有頭結點
                                if(lowTailNode == null){
                                    lowHeadNode = currentNode;
                                }else{
                                    lowTailNode.next = currentNode;
                                }
                                lowTailNode = currentNode;
                            }else{
                                if(highTailNode == null){
                                    highHeadNode = currentNode;
                                }else{
                                    highTailNode.next = currentNode;
                                }
                                highTailNode = currentNode;
                            }
                            //繼續迴圈當前節點的下一個節點
                            currentNode = currentNode.next;
                        } while (currentNode.next != null);
                        //如果hash&oldCapacity = 0 則說明這個連結串列的元素在新HashMap容器中，陣列下表位置不變
                        if(lowTailNode != null){
                            lowTailNode.next = null;
                            newTable[i] = lowHeadNode;
                        }
                        if(highTailNode != null){
                            highTailNode.next = null;
                            newTable[i + oldCapacity] = highHeadNode;
                        }
                    }
                }
            }
        }

        return newTable;
    }

6.HashMap的get方法

    public V get(Object key) {

        Node<K, V> node = null;
        node = getNode(hash(key), key);

        return node == null ? null : node.value;
    }

    private Node<K, V> getNode(int hash, Object key) {
        Node<K, V>[] tempTable = table;
        int capacity = tempTable.length;
        //如果當前HashMap容器為空或者其容量為0，則直接返回null
        if (tempTable == null || capacity == 0) {
            return null;
        }

        //要查詢的key值，如果存在，則在容器中的位置為
        int location = hash & (capacity - 1);
        Node<K, V> firstNode = tempTable[location];
        if (firstNode == null) {
            return null;
        }
        if (firstNode.hash == hash
                && (firstNode.key == key
                    || (key != null && key.equals(firstNode.key)))) {
            return firstNode;
        }
        Node<K,V> nextNode = firstNode.next;
        //是不是連結串列
        if(nextNode != null){
            if(nextNode instanceof TreeNode){
                //TODO 紅黑樹結構的處理
            }else{
                do{
                    if (nextNode.hash == hash
                            && (nextNode.key == key
                            || (key != null && key.equals(nextNode.key)))) {
                        return nextNode;
                    }
                    nextNode = nextNode.next;
                }while (nextNode != null);
            }
        }
        return null;
    }

7.HashMap的remove方法

    public V remove(Object key) {
        Node<K, V> removeNode = null;

        removeNode = removeNode(hash(key), key);

        return removeNode == null ? null : removeNode.value;

    }

    private Node<K, V> removeNode(int hash, Object key) {
        Node<K, V> removeNode = null;
        Node<K, V> prevNode = null;
        Node<K, V>[] tempTable = table;
        int capacity = tempTable.length;
        //如果當前HashMap容器為空或者其容量為0，則直接返回null
        if (tempTable == null || capacity == 0) {
            return null;
        }

        //要查詢的key值，如果存在，則在容器中的位置為
        int location = hash & (capacity - 1);
        Node<K, V> firstNode = tempTable[location];
        if (firstNode == null) {
            return null;
        }

        if (firstNode.hash == hash
                && (firstNode.key == key
                || (key != null && key.equals(firstNode.key)))) {
            removeNode = firstNode;
            prevNode = firstNode;
        }
        Node<K, V> nextNode = firstNode.next;
        //是不是連結串列
        if (removeNode == null & nextNode != null) {
            if (nextNode instanceof TreeNode) {
                //TODO 紅黑樹結構的處理
            } else {
                do {
                    if (nextNode.hash == hash
                            && (nextNode.key == key
                            || (key != null && key.equals(nextNode.key)))) {
                        removeNode = nextNode;
                        break;
                    }
                    prevNode = nextNode;
                    nextNode = nextNode.next;
                } while (nextNode != null);
            }
        }
        //如果要刪除的元素存在
        if (removeNode != null) {
            //如果刪除的是
            if (removeNode instanceof TreeNode) {
                //TODO 紅黑樹
            }
            //如果刪除不是單向連結串列，這個位置只有一個元素，並且匹配上了
            else if (removeNode == prevNode) {
                tempTable[location] = removeNode.next;
            }else{
                prevNode.next = removeNode.next;
            }
            --size;
            return removeNode;
        }
        return null;
    }

8.自己手寫HashMap原始碼程式碼以及Junit測試類

package com.roger.collection.impl;

import javax.swing.tree.TreeNode;
import java.util.Objects;

public class RogerHashMap<K, V> {
    //單向連結串列轉向紅黑樹的條件判斷
    static final int TREEIFY_THRESHOLD = 8;
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    //HashMap中陣列的最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
    static final float DEFAULT_LOAD_FACTOR = 0.75F;

    static class Node<K, V> {
        final int hash;
        final K key;
        V value;
        Node<K, V> next;

        public Node(int hash, K key, V value, Node<K, V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        @Override
        public String toString() {
            return key + " = " + value;
        }

        //設定成新值，返回舊值
        public final V setValue(V newValue) {
            V oldValue = value;
            this.value = newValue;
            return oldValue;
        }

        @Override
        public int hashCode() {
            return Objects.hash(key) ^ Objects.hash(value);
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Node<?, ?> node = (Node<?, ?>) o;
            return Objects.equals(key, node.key) &&
                    Objects.equals(value, node.value);
        }
    }

    //HashMap容器下一次擴容的標準
    //即當HashMap容器中元素的個數大於這個值
    //就會觸發HashMap容器擴容
    //JDK1.8保證這個值是2的次方數
    int threshold;
    //負載因子
    final float loadFactor;
    //HashMap容器中元素的個數
    int size;

    public RogerHashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
    }

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

    public RogerHashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("Illegal initial capacity : " + initialCapacity);
        }

        if (initialCapacity > MAXIMUM_CAPACITY) {
            initialCapacity = MAXIMUM_CAPACITY;
        }

        if (loadFactor < 0) {
            throw new IllegalArgumentException("Illegal load factor : " + loadFactor);
        }

        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

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

    Node<K, V>[] table;

    public V get(Object key) {

        Node<K, V> node = null;
        node = getNode(hash(key), key);

        return node == null ? null : node.value;
    }

    private Node<K, V> getNode(int hash, Object key) {
        Node<K, V>[] tempTable = table;
        int capacity = tempTable.length;
        //如果當前HashMap容器為空或者其容量為0，則直接返回null
        if (tempTable == null || capacity == 0) {
            return null;
        }

        //要查詢的key值，如果存在，則在容器中的位置為
        int location = hash & (capacity - 1);
        Node<K, V> firstNode = tempTable[location];
        if (firstNode == null) {
            return null;
        }
        if (firstNode.hash == hash
                && (firstNode.key == key
                || (key != null && key.equals(firstNode.key)))) {
            return firstNode;
        }
        Node<K, V> nextNode = firstNode.next;
        //是不是連結串列
        if (nextNode != null) {
            if (nextNode instanceof TreeNode) {
                //TODO 紅黑樹結構的處理
            } else {
                do {
                    if (nextNode.hash == hash
                            && (nextNode.key == key
                            || (key != null && key.equals(nextNode.key)))) {
                        return nextNode;
                    }
                    nextNode = nextNode.next;
                } while (nextNode != null);
            }
        }
        return null;
    }

    public V remove(Object key) {
        Node<K, V> removeNode = null;

        removeNode = removeNode(hash(key), key);

        return removeNode == null ? null : removeNode.value;

    }

    private Node<K, V> removeNode(int hash, Object key) {
        Node<K, V> removeNode = null;
        Node<K, V> prevNode = null;
        Node<K, V>[] tempTable = table;
        int capacity = tempTable.length;
        //如果當前HashMap容器為空或者其容量為0，則直接返回null
        if (tempTable == null || capacity == 0) {
            return null;
        }

        //要查詢的key值，如果存在，則在容器中的位置為
        int location = hash & (capacity - 1);
        Node<K, V> firstNode = tempTable[location];
        if (firstNode == null) {
            return null;
        }

        if (firstNode.hash == hash
                && (firstNode.key == key
                || (key != null && key.equals(firstNode.key)))) {
            removeNode = firstNode;
            prevNode = firstNode;
        }
        Node<K, V> nextNode = firstNode.next;
        //是不是連結串列
        if (removeNode == null & nextNode != null) {
            if (nextNode instanceof TreeNode) {
                //TODO 紅黑樹結構的處理
            } else {
                do {
                    if (nextNode.hash == hash
                            && (nextNode.key == key
                            || (key != null && key.equals(nextNode.key)))) {
                        removeNode = nextNode;
                        break;
                    }
                    prevNode = nextNode;
                    nextNode = nextNode.next;
                } while (nextNode != null);
            }
        }
        //如果要刪除的元素存在
        if (removeNode != null) {
            //如果刪除的是
            if (removeNode instanceof TreeNode) {
                //TODO 紅黑樹
            }
            //如果刪除不是單向連結串列，這個位置只有一個元素，並且匹配上了
            else if (removeNode == prevNode) {
                tempTable[location] = removeNode.next;
            }else{
                prevNode.next = removeNode.next;
            }
            --size;
            return removeNode;
        }
        return null;
    }

    public V put(K key, V value) {
        return putVal(hash(key), key, value);
    }

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    private V putVal(int hash, K key, V value) {
        //定義一個臨時變數用來儲存HashMap容器的容量大小
        int capacity;
        //定義一個新元素在HashMap中數組裡面的下表位置
        int currentIndex;

        //把HashMap容器的元素賦值給一個臨時變數
        Node<K, V>[] tempTable = table;
        //如果HashMap容器為空或者容量為0，則需要擴容
        if (tempTable == null || tempTable.length == 0) {
            tempTable = resize();
        }
        capacity = tempTable.length;
        //計算新增的值將要儲存的位置
        currentIndex = (capacity - 1) & hash;
        //從HashMap中取出當前位置的元素
        Node<K, V> tempNode = tempTable[currentIndex];
        //如果HashMap容器的當前位置還沒有儲存元素
        //則直接把信元素賦值到這個位置即可
        if (tempNode == null) {
            tempTable[currentIndex] = new Node<>(hash, key, value, null);
        } else {
            Node<K, V> modifyNode = null;
            //如果當前位置已經儲存了元素，則需要根據不同的情況來處理這個元素
            Node<K, V> currentNode = tempNode;
            //1.如果新增的元素的hash(key)相同,並且（key 的物件 和 當前物件 相等 || key!=null && key值和當前的key相等），
            // 則需要更新當前節點的值
            //2.如果當前節點的型別是紅黑樹，則進入紅黑樹的邏輯進行處理--這裡不做說明
            //3.進入單線連結串列的迴圈處理，如果在連結串列中找到和新增的元素的hash(key),key值和當前節點的都相同，並且key！= null的節點
            //只需把這個節點的值更新即可，否則直接新增到連結串列的末尾
            K currentKey = currentNode.key;
            int currentHash = currentNode.hash;
            if (currentHash == hash && (currentKey == key || key != null && key.equals(currentKey))) {
                modifyNode = currentNode;
            } else if (currentNode instanceof TreeNode) {
                //TODO jdk1.8後才有的
            } else {
                for (int bitCount = 0; ; bitCount++) {
                    Node<K, V> nextNode = currentNode.next;
                    //如果當前節點的下一個節點為null，則到了單向連結串列的尾節點
                    //直接把新元素新增到單向連結串列的結尾即可
                    if (nextNode == null) {
                        nextNode.next = new Node<>(hash, key, value, null);
                        if (bitCount >= TREEIFY_THRESHOLD - 1) {
                            //TODO 如果單向連結串列的元素個數大於所設定的向紅黑樹轉變的條件，則需要處理
                        }
                        break;
                    }
                    //如果當前節點的下一個節點不為null，則判斷新節點和當前節點是否滿足相同節點的條件
                    if (nextNode.hash == hash && (nextNode.key == key || key != null && key.equals(nextNode.key))) {
                        modifyNode = nextNode;
                        break;
                    }
                    //如果沒有遍歷到單向連結串列的末尾，並且新節點不是當前節點
                    //則繼續遍歷
                    currentNode = nextNode;
                }
            }

            //如果在單向連結串列中存在節點和新節點相同的條件，則只需要把舊節點的資料修改成新的值即可
            if (modifyNode != null) {
                V oldValue = modifyNode.value;
                //TODO 如果有引數設定，節點已經存在，切節點的值不為null就不在新增，則不需要更新節點的值
                modifyNode.value = value;
                return oldValue;
            }

        }

        size++;
        //如果容器中元素的個數大於
        // HashMap容器根據負載因子設定的閾值
        // 則需要擴容，並重新分配HashMap中元素的位置
        if (size > threshold) {
            resize();
        }
        return null;
    }

    /**
     * 初始化HashMap容器，或者重新分配HashMap容器中元素的位置
     * 因為當HashMap容器中元素超過一定的數量，需要擴容，
     * 而擴容之後元素hash值發生變化，所以需要重新分配HashMap容器中元素的位置
     */
    final Node<K, V>[] resize() {
        //定義一個臨時變數儲存舊的HashMap容器中的元素集合
        Node<K, V>[] oldTable = table;
        //舊HashMap容器的容量大小為
        int oldCapacity = oldTable == null ? 0 : oldTable.length;
        //舊的擴容標準
        int oldThreshold = threshold;
        //定義臨時變數儲存新容器容量和新擴容標準
        int newCapactity = 0;
        int newThreshold = 0;
        //如果舊的HashMap容器大於0
        if (oldCapacity > 0) {
            //如果舊的HashMap容器已經達到HashMap允許的最大容量
            //則只需把擴容標準放大到最大即可
            if (oldCapacity >= MAXIMUM_CAPACITY) {
                threshold = MAXIMUM_CAPACITY;
                return oldTable;
            }
            //如果舊的HashMap容器還沒有達到HashMap允許的最大容量
            //則把舊的容量擴大兩倍作為新的容器的容量
            newCapactity = oldCapacity << 1;
            //如果擴大後的容器容量小於HashMap允許的最大容量
            //並且大於等於預設的最小初始容量
            //則把舊的擴容標準加倍
            if (newCapactity < MAXIMUM_CAPACITY && newCapactity >= DEFAULT_INITIAL_CAPACITY) {
                newThreshold = oldThreshold << 1;
            }
        }
        //如果舊的擴容標準大於0
        else if (oldThreshold > 0) {
            newCapactity = oldThreshold;
        } else {
            // 如果上面兩個條件都不滿足，則取HashMap容器預設的標準
            newCapactity = DEFAULT_INITIAL_CAPACITY;
            newThreshold = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        threshold = newThreshold;
        //使用新的容量建立HashMap容器
        Node<K, V>[] newTable = (Node<K, V>[]) new Node[newCapactity];
        //將新HashMap容器賦值給HashMap容器
        table = newTable;
        //如果舊的HashMap容器不為空，則需要重新分配HashMap容器中的元素
        if (oldTable != null) {
            for (int i = 0; i < oldCapacity; i++) {
                Node<K, V> currentNode = oldTable[i];
                //舊HashMap容器當前位置不為空，則需要根據新的容量重新計算該元素應該存放的位置
                if (currentNode != null) {
                    oldTable[i] = null;//為了讓GC回收
                    //判斷當前節點是否有下下一個節點，如果沒有，則直接進行元素位置的重新計算
                    if (currentNode.next == null) {
                        int currentHash = currentNode.hash;
                        int newIndex = currentHash & (newCapactity - 1);
                        newTable[newIndex] = currentNode;
                    } else if (currentNode instanceof TreeNode) {
                        //TODO 如果當前節點的型別是紅黑樹
                    } else {
                        //同一個單向連結串列中元素的hash值是相等的
                        //因此在新的HashMap容器中，這個連結串列中所有的元素，
                        // 也還是在相同的位置，並且是連結串列的格式儲存
                        Node<K, V> highHeadNode = null;
                        Node<K, V> highTailNode = null;
                        Node<K, V> lowHeadNode = null;
                        Node<K, V> lowTailNode = null;
                        do {
                            int currentHash = currentNode.hash;
                            int hashLocation = currentHash & oldCapacity;
                            if (hashLocation == 0) {
                                //如果尾部節點還沒有設定，則說明此時還沒有頭結點
                                if (lowTailNode == null) {
                                    lowHeadNode = currentNode;
                                } else {
                                    lowTailNode.next = currentNode;
                                }
                                lowTailNode = currentNode;
                            } else {
                                if (highTailNode == null) {
                                    highHeadNode = currentNode;
                                } else {
                                    highTailNode.next = currentNode;
                                }
                                highTailNode = currentNode;
                            }
                            //繼續迴圈當前節點的下一個節點
                            currentNode = currentNode.next;
                        } while (currentNode.next != null);
                        //如果hash&oldCapacity = 0 則說明這個連結串列的元素在新HashMap容器中，陣列下表位置不變
                        if (lowTailNode != null) {
                            lowTailNode.next = null;
                            newTable[i] = lowHeadNode;
                        }
                        if (highTailNode != null) {
                            highTailNode.next = null;
                            newTable[i + oldCapacity] = highHeadNode;
                        }
                    }
                }
            }
        }

        return newTable;
    }
}

package com.roger.collection.impl;

import org.junit.Test;

import static org.junit.Assert.*;

public class RogerHashMapTest {

    @Test
    public void testPut() {

        RogerHashMap<String, Object> rogerHashMap = new RogerHashMap<>(2);

        rogerHashMap.put("name", "Roger");
        rogerHashMap.put("age", 12);
        rogerHashMap.put("address", "上海");
        rogerHashMap.remove("name");
        System.out.println("name:" + rogerHashMap.get("name"));
        System.out.println("age:" + rogerHashMap.get("age"));
        System.out.println("address:" + rogerHashMap.get("address"));

    }
}