在通過上篇部落格瞭解了 Map 的維持內部的 鍵-值 對的基本方式之後,----不瞭解的看這篇(Java集合的基本概括), 我們便會思考, 在 HashMap 內部是如何組織和排列這些封裝了 鍵-值對的 Map.Entry 實體呢? 如何組織才能達到更高的效率呢?

在瞭解 HashMap 的雜湊機制之前, 我們不妨來假設一下 HashMap 內部的資料結構的排列方式.

• 通過陣列來維持內部的 鍵-值 對.

陣列也許是我們最容易想到的一種資料結構, 我們知道, 儲存一組資料最快的資料結構便是陣列,這也是陣列僅存的優點, 同樣陣列的缺陷也很明顯, 比如 需要大量的連續的記憶體空間, 對元素的插入操作代價高昂,不能隨意的擴大容量....等等.

因此,如果在 HashMap 的內部通過陣列來維持 鍵-值 對, 在我們增加元素的時候似乎開銷不大, 但是當我們用一個 key 去獲取一個 value的時候, 想想我們該怎麼去實現, 最常見的方式便是對 key 進行線性的 equals 查詢, 從頭查到尾, 這樣的查詢速度如此低下, 效率可想而知, 還有一個缺陷便就是陣列與生俱來的, 需要太大的連續的記憶體空間, 所以通過陣列來維持 HashMap 內部的資料缺陷太大,不值得.

• 通過連結串列來維持

在上面說過陣列的那麼多缺陷之後, 可能很多同學便會說到用連結串列, 沒錯連結串列似乎是解決了陣列一個最致命的缺陷(需要大量的連續的記憶體空間), 但是連結串列仍然無法解決當我們用一個 key 去查詢一個 value 的時候的低下的效率, 原因仍然是從頭到尾的線性遍歷.....

在上面我們說到用陣列或者連結串列來維護內部的 鍵-值 對似乎效率都很低下,有沒有一種能夠結合陣列和連結串列兩者各自的優點然後又有著高效的查詢速度的資料結構呢?

這便是 HashMap 內部維護資料的方式 --- 陣列連結串列+雜湊機制

為速度而雜湊:

雜湊的價值便在於速度, 雜湊使得查詢得以快速進行, 那麼什麼是陣列連結串列,什麼又是雜湊機制呢?

• 正所謂陣列連結串列, 便是定義一個數組, 然後陣列的每一個成員都是一條連結串列,陣列只需要記載這條連結串列的引用即可, 這樣不需要直接在陣列內部儲存 鍵-值 對而需要大量的連續的記憶體空間.
• 雜湊機制便是所謂的 hashCode 方法返回的 int 數, 他是通過物件的資訊(預設是地址),通過某種雜湊的數學函式生成的一串 int 數字.

在瞭解了陣列連結串列和雜湊機制後,我們再來想一想 HashMap 內部的 鍵-值 對是如何高效的維持的.

• 首先, 仍然會定義一個數組, 這個陣列的是一個儲存連結串列的引用陣列, 從而解決了陣列因儲存物件而需要大量的連續的記憶體空間的缺陷.
• 然後, 我們在 put 一個元素的時候, 會呼叫 key 的 HashCode 方法生成一個雜湊碼, 然後用這個雜湊碼餘上陣列的容量,從而得到了一個數組的下標, 然後把這個 鍵-值 對儲存在這個下標下對應的連結串列內.
• 在理想的情況下, 假設沒有雜湊衝突(不同的物件產生了相同的雜湊碼), 在我們用 key 去查詢一個 value 的時候, 仍然用這個雜湊函式得到陣列的下標, 從而直接獲取了對應的 value, 這個效率簡直了.....提升了多少倍啊.....
• 可是不會產生衝突的雜湊函式是幾乎不存在的, 於是乎便會出現不同的 key 產生了相同的雜湊碼, 在我們查詢的時候就得采用 equals 線性遍歷這少部分的因衝突而儲存在一個連結串列中的 鍵-值 對, 但是這和全部的元素進行線性遍歷, 效率仍然是提高了很多倍.

通過上面的解釋, 採用 陣列連結串列和雜湊機制 來實現的 HashMap為什麼效率這麼高的原因理解了, 下面來實現一個簡單的 HashMap.

   class MyHashMap<k, v> extends AbstractMap<k, v> {

        private static final int SIZE = 16;
        LinkedList<Map.Entry<k, v>>[] buckets = new LinkedList[SIZE];

        @Override
        public v put(k key, v value) {
            int index = key.hashCode() % SIZE;
            if (buckets[index] == null) {
                buckets[index] = new LinkedList<>();
            }

            boolean found = false;
            Map.Entry<k, v> pair = new HashMap.SimpleEntry<>(key, value);
            v oldValue = null;
            // Begin to found whether already have this key and value.
            for (Entry<k, v> kvEntry : buckets[index]) {
                // If already have this key, replace value.
                if (kvEntry.getKey().equals(key)) {
                    oldValue = kvEntry.getValue();
                    found = true;
                    buckets[index].set(buckets[index].indexOf(kvEntry), pair);
                    break;
                }
            }
            // If not found, add the new key-value to the linked end.
            if (!found) {
                buckets[index].add(pair);
            }
            return oldValue;
        }

        @Override
        public v get(Object key) {
            // Use hash code to get index.
            int index = key.hashCode() % SIZE;
            if (buckets[index] == null) {
                return null;
            }
            for (Entry<k, v> kvEntry : buckets[index]) {
                // If have this key, return value.
                if (kvEntry.getKey().equals(key)) {
                    return kvEntry.getValue();
                }
            }
            return null;
        }

        @Override
        public Set<Entry<k, v>> entrySet() {
            HashSet<Entry<k, v>> entryHashSet = new HashSet<>();
            for (LinkedList<Entry<k, v>> bucket : buckets) {
                if (bucket != null) {
                    entryHashSet.addAll(bucket);
                }
            }
            return entryHashSet;
        }
    }

• 看了上面實現一個簡單的 HashMap 的原理後, 我們便明白為什麼當我們使用自定義的型別作為 鍵 的時候必須同時覆寫 equals 和hashcode 方法了.
• 一個好的雜湊函式應該要能跟產生均勻的雜湊碼, 並且雜湊碼並不要求唯一, 更加關注的應該是其生成的速度,我們最好使用物件的某些有意義的資訊來生成雜湊碼.
• 用來生成雜湊碼的資訊應該是不能輕易改變的值,如果你對同一個 key 呼叫 hashCode 卻生成了兩個不一樣的雜湊碼, 那麼你將無法獲取到之前的 value.

未完待續......對HashMap原始碼的解析.....