有關 HashMap 面試官常問的一些問題

時間 2020-07-07

原文原文鏈接

前言

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

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

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

== 和 equals() 的區別？面試

爲何重寫 equals() 就必需要重寫 hashCode()？算法

Hashtable, HashSet 和 HashMap 的區別和聯繫數組

處理 hash 衝突有哪些方法？Java 中用的哪種？爲何？另外一種方法你在工做中用過嗎？在什麼狀況下用得多？安全

徒手實現一個 HashMap 吧bash

本文分如下章節：數據結構

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，那麼 == 就是比較數值的大小；若是是 reference type，那麼就比較的是這兩個 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 falsestr1.equals(str2); // return true複製代碼

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

老祖宗留給你就是讓你本身用的，若是你不用，那人家也提供了默認的方法，也是夠意思了。

好了，咱們再去看 hashCode() 的介紹：

那至於 hashCode() 返回的到底是什麼，和本文關聯不太大，有興趣的同窗能夠看參考這篇文章[1]，結論就是：

返回的並不必定是對象的（虛擬）內存地址，具體取決於運行時庫和JVM的具體實現。

但不管是怎麼實現的，都須要遵循文檔上的約定，也就是對不一樣的 object 會返回惟一的哈希值。

哈希衝突詳解

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

Separate chaining

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) 來說：

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

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

那拿到了這個位置的 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 個。

實現：

建一個 HashMap <key = 單詞，value = 出現頻率>，遍歷整個數組，相應的把這個單詞的出現次數 + 1.

這一步時間複雜度是 O(n).

用 size = k 的 minHeap 來存放結果，定義好題目中規定的比較順序
a. 首先按照出現的頻率排序；
b. 頻率相同時，按字母順序。
遍歷這個 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;    }}複製代碼

這就是本文的所有內容了。若是以爲寫的不錯，請記得收藏加轉發。