有關 HashMap 面試會問的一切

前言

HashMap 是不管在工做仍是面試中都很是常見常考的數據結構。

好比 Leetcode 第一題 Two Sum 的某種變種的最優解就是須要用到 HashMap 的，高頻考題 LRU Cache 是須要用到 LinkedHashMap 的。

HashMap 用起來很簡單，底層實現也不復雜，先來看幾道常見的面試題吧。相信你們多多少少都能回答上來一點，不清楚的地方就仔細閱讀本文啦～這篇文章帶你深挖到 HashMap 的老祖宗，保證吊打面試官

• == 和 equals() 的區別？
• 爲何重寫 equals() 就必需要重寫 hashCode()？
• Hashtable, HashSet 和 HashMap 的區別和聯繫
• 處理 hash 衝突有哪些方法？Java 中用的哪種？爲何？另外一種方法你在工做中用過嗎？在什麼情 況下用得多？
• 徒手實現一個 HashMap 吧

本文分如下章節：

• Set 和 Map 家族簡介
• HashMap 實現原理
• 關於 hashCode() 和 equals()
• 哈希衝突詳解
• HashMap 基本操做
• 高頻面試考題分析

Set 家族

在講 Map 以前，咱們先來看看 Set。

集合的概念咱們初中數學就學過了，就是裏面不能有重複元素，這裏也是同樣。

Set 在 Java 中是一個接口，能夠看到它是 java.util 包中的一個集合框架類，具體的實現類有不少：

其中比較經常使用的有三種：

HashSet: 採用 Hashmap 的 key 來儲存元素，主要特色是無序的，基本操做都是 O(1) 的時間複雜度，很快。

LinkedHashSet: 這個是一個 HashSet + LinkedList 的結構，特色就是既擁有了 O(1) 的時間複雜度，又可以保留插入的順序。

TreeSet: 採用紅黑樹結構，特色是能夠有序，能夠用天然排序或者自定義比較器來排序；缺點就是查詢速度沒有 HashSet 快。

Map 家族

Map 是一個鍵值對 (Key - Value pairs)，其中 key 是不能夠重複的，畢竟 set 中的 key 要存在這裏面。

那麼與 Set 相對應的，Map 也有這三個實現類：

HashMap: 與 HashSet 對應，也是無序的，O(1)。

LinkedHashMap: 這是一個「HashMap + 雙向鏈表」的結構，落腳點是 HashMap，因此既擁有 HashMap 的全部特性還能有順序。

TreeMap: 是有序的，本質是用二叉搜索樹來實現的。

HashMap 實現原理

對於 HashMap 中的每一個 key，首先經過 hash function 計算出一個 hash 值，這個hash值就表明了在 buckets 裏的編號，而 buckets 其實是用數組來實現的，因此把這個數值模上數組的長度獲得它在數組的 index，就這樣把它放在了數組裏。

那麼這裏有幾個問題：

若是不一樣的元素算出了相同的哈希值，那麼該怎麼存放呢？

答：這就是哈希碰撞，即多個 key 對應了同一個桶。

HashMap 中是如何保證元素的惟一性的呢？即相同的元素會不會算出不一樣的哈希值呢？

答：經過 hashCode() 和 equals() 方法來保證元素的惟一性。

若是 pairs 太多，buckets 太少怎麼破？

答：Rehasing. 也就是碰撞太多的時候，會把數組擴容至兩倍（默認）。因此這樣雖然 hash 值沒有變，可是由於數組的長度變了，因此算出來的 index 就變了，就會被分配到不一樣的位置上了，就不用擠在一塊兒了，小夥伴們咱們江湖再見～

那何時會 rehashing 呢？也就是怎麼衡量桶裏是否是足夠擁擠要擴容了呢？

答：load factor. 即用 pair 的數量除以 buckets 的數量，也就是平均每一個桶裏裝幾對。Java 中默認值是 0.75f，若是超過了這個值就會 rehashing.

關於 hashCode() 和 equals()

若是 key 的 hashCode() 值相同，那麼有多是要發生 hash collision 了，也有多是真的遇到了另外一個本身。那麼如何判斷呢？繼續用 equals() 來比較。

也就是說，

hashCode() 決定了 key 放在這個桶裏的編號，也就是在數組裏的 index；

equals() 是用來比較兩個 object 是否相同的。

那麼該如何回答這道經典面試題：

爲何重寫 equals() 方法，必定要重寫 hashCode() 呢？

答：首先咱們有一個假設：任何兩個 object 的 hashCode 都是不一樣的。
那麼在這個條件下，有兩個 object 是相等的，那若是不重寫 hashCode()，算出來的哈希值都不同，就會去到不一樣的 buckets 了，就迷失在茫茫人海中了，再也沒法相認，就和 equals() 條件矛盾了，證畢。

撒花～～🎉🎉🎉

接下來咱們再對這兩個方法一探究竟：

其實 hashCode() 和 equals() 方法都是在 Object class 這個老祖宗裏定義的，Object 是全部 Java 中的 class 的鼻祖，默認都是有的，甩不掉的。

那既然是白給的，咱們先來看看大禮包裏有什麼，谷歌 Object 的 Oracle 文檔：

因此這些方法都是能夠直接拿來用的呢～

回到 hashCode() 和 equals()，那麼若是這個新的 class 裏沒有重寫 (override) 這兩個方法，就是默認繼承 Object class 裏的定義了。

那咱們點進去來看看 equals() 是怎麼定義的：

記筆記：

equals() 方法就是比較這兩個 references 是否指向了同一個 object.

嗯？？？你在逗我嗎？？那豈不是和 == 同樣了？？

補充：
咱們經常使用的比較大小的符號之 ==
若是是 primitive type，那麼 == 就是比較數值的大小；
若是是 referencetype，那麼就比較的是這兩個 reference 是否指向了同一個 object。

再補充：
Java 的數據類型能夠分爲兩種：
Primitive type 有且僅有8種：
byte, short, int, long,float, double, char, boolean. 其餘都是 Reference type.
因此雖然 Java 聲稱 「Everything is object」，可是仍是有非 object 數據類型的存在的。

我不信，我要去源碼裏看看它是怎麼實現的。

哈，還真是的，繞了這麼半天，equals() 就是用 == 來實現的！

那爲何還弄出來這麼個方法呢？

答：爲了讓你 override～

好比通常來講咱們比較字符串就是想比較這兩個字符串的內容的，那麼：

str1 = 「tianxiaoqi」;
str2 =  new String(「tianxiaoqi」);

str1 == str2; // return false
str1.equals(str2); // return true

由於 String 裏是重寫了 equals() 方法的：

老祖宗留給你就是讓你本身用的，若是你不用，那人家也提供了默認的方法，也是夠意思了。
好了，咱們再去看 hashCode() 的介紹：

結論就是：

返回的並不必定是對象的（虛擬）內存地址，具體取決於運行時庫和JVM的具體實現。 但不管是怎麼實現的，都須要遵循文檔上的約定，也就是對不一樣的
object 會返回惟一的哈希值。

哈希衝突詳解

通常來講哈希衝突有兩大類解決方式[2]

1. Separate chaining
2. Open addressing

Java 中採用的是第一種 Separate chaining，即在發生碰撞的那個桶後面再加一條「鏈」來存儲，那麼這個「鏈」使用的具體是什麼數據結構，不一樣的版本稍有不一樣：

在 JDK1.6 和 1.7 中，是用鏈表存儲的，這樣若是碰撞不少的話，就變成了在鏈表上的查找，worst case 就是 O(n)；

在 JDK 1.8 進行了優化，當鏈表長度較大時（超過 8），會採用紅黑樹來存儲，這樣大大提升了查找效率。

（話說，這個還真的喜歡考，已經在屢次面試中被問過了，還有面試官問爲何是超過「8」才用紅黑樹🤔）

第二種方法 open addressing 也是很是重要的思想，由於在真實的分佈式系統裏，有不少地方會用到 hash 的思想但又不適合用 seprate chaining。

這種方法是順序查找，若是這個桶裏已經被佔了，那就按照「某種方式」繼續找下一個沒有被佔的桶，直到找到第一個空的。

如圖所示，John Smith 和 Sandra Dee 發生了哈希衝突，都被計算到 152 號桶，因而 Sandra 就去了下一個空位 - 153 號桶，固然也會對以後的 key 發生影響：Ted Baker 計算結果本應是放在 153 號的，但鑑於已經被 Sandra 佔了，就只能再去下一個空位了，因此到了 154 號。

這種方式叫作 Linear probing 線性探查，就像上圖所示，一個個的順着找下一個空位。固然還有其餘的方式，好比去找平方數，或者 Double hashing.

HashMap 基本操做

每種數據結構的基本操做都無外乎增刪改查這四種，具體到 HashMap 來講，

• 增：put(K key, V value)
• 刪：remove(Object key)
• 改：仍是用的 put(K key, V value)
• 查：get(Object key) / containsKey(Object key)

細心的同窗可能發現了，爲何有些 key 的類型是 Object，有些是 K 呢？這還不是由於 equals()...

這是由於，在 get/remove 的時候，不必定是用的同一個 object。

還記得那個 str1 和 str2 都是田小齊的例子嗎？那好比我先 put(str1, value)，而後用 get(str2) 的時候，也是想要到 tianxiaoqi 對應的 value 呀！不能由於我換了身衣服就不認得我了呀！因此在 get/remove 的時候並無很限制 key 的類型，方便另外一個本身相認。

其實這些 API 的操做流程大同小異，咱們以最複雜的 put(K key, V value) 來說：

1.首先要拿到 array 中要放的位置的 index

• 怎麼找 index 呢，這裏咱們能夠單獨用 getIndex() method 來作這件事；
• 具體怎麼作，就是經過 hash function 算出來的值，模上數組的長度；

2.那拿到了這個位置的 Node，咱們開始 traverse 這個 LinkedList，這就是在鏈表上的操做了，

• 若是找的到，就更新一下 value；
• 若是沒找到，就把它放在鏈表上，能夠放頭上，也能夠放尾上，通常我喜歡放頭上，由於新加入的元素用到的機率老是大一些，但並不影響時間複雜度。

代碼以下：

public V put(K key, V value) {
  int index = getIndex(key);
  Node<K, V> node = array[index];
  Node<K, V> head = node; 
  while (node != null) {
    // 原來有這個 key，僅更新值
    if (checkEquals(key, node)) {
      V preValue = node.value;
      node.value = value;
      return preValue;
    }
    node = node.next;
  }
  // 原來沒有這個 key，新加這個 node
  Node<K, V> newNode = new Node(key, value); 
  newNode.next = head;
  array[index] = newNode;
  return null;
}

至於更多的細節好比加一些 rehashing 啊，load factor 啊，你們能夠參考源碼。
讀完源碼你們能夠作作 Leetcode 706 題練手，so easy~

與 Hashtable 的區別

這是一個年齡暴露貼，HashMap 與 Hashtable 的關係，就像 ArrayList 與 Vector，以及 StringBuilder 與 StringBuffer。

Hashtable 是早期 JDK 提供的接口，HashMap 是新版的；它們之間最顯著的區別，就是 Hashtable 是線程安全的，HashMap 並不是線程安全。

這是由於 Java 5.0 以後容許數據結構不考慮線程安全的問題，由於實際工做中咱們發現沒有必要在數據結構的層面上上鎖，加鎖和放鎖在系統中是有開銷的，內部鎖有時候會成爲程序的瓶頸。

因此 HashMap, ArrayList, StringBuilder 再也不考慮線程安全的問題，性能提高了不少，固然，線程安全問題也就轉移給咱們程序員了。

另一個區別就是：HashMap 容許 key 中有 null 值，Hashtable 是不容許的。這樣的好處就是能夠給一個默認值。

好了，最後咱們看下常考題吧。

Top K 問題

很是常考的 Top K 問題，也是大廠面試中規中矩的題，這兩題大同小異，這裏以第一題爲例。

題意：
給一組詞，統計出現頻率最高的 k 個。
好比說 「I love leetcode, I love coding」 中頻率最高的 2
個就是 I 和 love 了。

有同窗以爲這題特別簡單，但其實這題只是母題，它能夠升級到系統設計層面來問：

在某電商網站上，過去的一小時內賣出的最多的 k 種貨物。

咱們先看算法層面:

思路：

統計下全部詞的頻率，而後按頻率排序取最高的前 k 個唄。

細節：

用 HashMap 存放單詞的頻率，用 minHeap/maxHeap 來取前 k 個。

實現：

1.建一個 HashMap <key = 單詞，value = 出現頻率>，遍歷整個數組，相應的把這個單詞的出現次數 + 1
這一步時間複雜度是 O(n)
.
2.用 size = k 的 minHeap 來存放結果，定義好題目中規定的比較順序
a. 首先按照出現的頻率排序；
b. 頻率相同時，按字母順序。

3.遍歷這個 map，若是
a. minHeap 裏面的單詞數還不到 k 個的時候就加進去；
b. 或者遇到更高頻的單詞就把它替換掉。

時空複雜度分析：

第一步是 O(n)，第三步是 nlog(k)，因此加在一塊兒時間複雜度是 O(nlogk).
用了一個額外的 heap 和 map，空間複雜度是 O(n).
代碼：

class Solution {
    public List<String> topKFrequent(String[] words, int k) {
        // Step 1
        Map<String, Integer> map = new HashMap<>();
        for (String word : words) {
            Integer count = map.getOrDefault(word, 0);
            count++;
            map.put(word, count);
        }
        
        // Step 2
        PriorityQueue<Map.Entry<String, Integer>> minHeap = new PriorityQueue<>(k+1, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2) {
                if(e1.getValue() == e2.getValue()) {
                    return e2.getKey().compareTo(e1.getKey());
                }
                return e1.getValue().compareTo(e2.getValue());
            }
        });
        
        // Step 3
        List<String> res = new ArrayList<>();
        for(Map.Entry<String, Integer> entry : map.entrySet()) {
            minHeap.offer(entry);
            if(minHeap.size() > k) {
                minHeap.poll();
            }
        }
        while(!minHeap.isEmpty()) {
            res.add(minHeap.poll().getKey());
        }
        Collections.reverse(res);
        return res;
    }
}

LRU Cache

這真的是不論國內面試仍是北美面試都很是喜歡考的一道題了。
可是鑑於本文篇幅以及這個週末還加了會班，沒有時間寫了，若是有想看的小夥伴就給我留言吧。
這就是本文的所有內容了。
若是以爲寫的不錯，請記得收藏加轉發。
還想跟我看更多數據結構和算法題的小夥伴們，記得關注我公衆號：程序零世界，Java 就這麼回事。

做者：小齊本齊