6、HashMap不是執行緒安全的，多執行緒環境下可以使用Hashtable或ConcurrentHashMap。

    7、我們能否讓HashMap同步？
         HashMap可以通過下面的語句進行同步：
         Map m = Collections.synchronizeMap(hashMap);

    圖1：

    圖2：

public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);// HashMap接收key為null的資料
        int hash = hash(key);//對key的hashCode再進行hash運算
        int i = indexFor(hash, table.length);//根據hash值和entry陣列的大小計算出新增資料應該存放的陣列位置
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            // for迴圈遍歷找到的陣列下標的entry，如果hash值和key都相等，則覆蓋原來的value值       
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        //如果上面for迴圈沒有找到相同的hash和key，則增加一個entry
        addEntry(hash, key, value, i);
        return null;
    }
	
	void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length); //如果size超過threshold，則擴充table大小。再雜湊
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }
    
    void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        //new 一個新的entry，賦值給當前下標陣列
        table[bucketIndex] = new Entry<>(hash, key, value, e); //引數e, 是Entry.next
        size++;
    }
    
    Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            //在HashMap的Entry中有四個變數，key、value、hash、next，其中next用於在hash方法新增值衝突時候，所指向的下一個值。
            next = n;//即將原來陣列下標對應的entry賦值給新的entry的next
            key = k;
            hash = h;
        }

       PS: HashMap，也是先判斷hashcode（hashcode相同，所以它們的table位置相同，‘碰撞’會發生。因為HashMap使用連結串列儲存物件，這個Entry(包含有鍵值對的Map.Entry物件)會儲存在連結串列中。），再判斷equals，如果都相同，則表示：在集合新增中，認為是同一個"東西"，覆蓋舊值。【==、equals、hashcode的區別和聯絡】

public V get(Object key) {
        if (key == null)//key為null時特別處理
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

        return null == entry ? null : entry.getValue();
    }
    
    final Entry<K,V> getEntry(Object key) {
        if (size == 0) {
            return null;
        }

        int hash = (key == null) ? 0 : hash(key);
        //indexFor(hash, table.length) 根據hash值和陣列長度計算出下標，然後遍歷Entry連結串列
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

static int indexFor(int h, int length) {
        return h & (length-1);
    }

void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }
	
	void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }