HashSet：實不相瞞，我就是個套殼 HashMap

HashSet：實不相瞞，我就是個套殼 HashMap

來自專輯
我有點兒基礎

古時的風箏第 82 篇原創文章

做者 | 風箏
公衆號：古時的風箏（ID：gushidefengzheng）
轉載請聯繫受權，掃碼文末二維碼加微信

題外話

據說公衆號又改版了，以前推送不是按時間線來了，也就是你在訂閱號消息中看到的推送是按照某種推薦規則來的，而不是按發文順序，這致使若是你們不往下多翻翻，可能都看不到某些號的推文了，好比我這個小號。（除非加星標）

這兩天的改變是公衆號底部除了「在看」外，增長了「贊」和「分享」這兩個功能，這個意思就是告訴各位同窗，你好不容易能看到個人文章一回，不三連一下分享、點贊、在看，實在於心不忍吧。着急的話，趕忙滑到底部 Trible Kill 一下，不着急的話，能夠看完文章再說。不差這幾分鐘的。

正文開始

以前的 7000 字說清楚 HashMap 已經詳細介紹了 HashMap 的原理和實現，本次再來講說他的同胞兄弟 HashSet，這兩兄弟常常被拿出來一塊兒說，面試的時候，也常常是二者結合着考察。難道它們兩個的實現方式很相似嗎，否則爲何老是放在一塊兒比較。

實際上並非由於它倆類似，從根本上來講，它倆原本就是同一個東西。再說的清楚明白一點， HashSet 就是個套了殼兒的 HashMap。所謂君子善假於物，HashSet 就假了 HashMap。既然你 HashMap 都擺在那兒了，那我 HashSet 何須重複造輪子，借你同樣，何不美哉！

HashSet

HashSet 是什麼

下面是 HashSet的繼承關係圖，仍是老樣子，咱們看一個數據結構的時候先看它的繼承關係圖。與 HashSet並列的還有 TreeSet，另外 HashSet 還有個子類型 LinkedHashSet，這個咱們後面再說。

HashSet 繼承關係

套殼 HashMap

爲啥這麼說呢，在我第一次看 HashSet源碼的時候，已經準備好了筆記本，拿好了圓珠筆，準備好好探究一下 HashSet的神奇所在。可當我按着Ctrl+鼠標左鍵進入源碼的構造函數的時候，我覺得我走錯了地方，這構造函數有點簡單，甚至還有點神奇。new 了一個 HashMap而且賦給了 map 屬性。

private transient HashMap<E,Object> map;

public HashSet() {
  map = new HashMap<>();
}

再三確認沒看錯的狀況下，我明白了，HashSet就是在HashMap的基礎上套了個殼兒，咱們用的是個HashSet，實際上它的內部存儲邏輯都是 HashMap的那套邏輯。

除了上面的那個無參類型的構造方法，還有其餘的有參構造方法，一看便知，其實就是 HashMap包裝了一層而已。

public HashSet(Collection<? extends E> c) {
  map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
  addAll(c);
}

public HashSet(int initialCapacity, float loadFactor) {
  map = new HashMap<>(initialCapacity, loadFactor);
}

public HashSet(int initialCapacity) {
  map = new HashMap<>(initialCapacity);
}

用法

HashSet應該算是衆多數據結構中最簡單的一個了，滿打滿算也就那麼幾個方法。

public Iterator<E> iterator() {
  return map.keySet().iterator();
}

public int size() {
  return map.size();
}

public boolean isEmpty() {
  return map.isEmpty();
}

public boolean contains(Object o) {
  return map.containsKey(o);
}

public boolean add(E e) {
  return map.put(e, PRESENT)==null;
}

public boolean remove(Object o) {
  return map.remove(o)==PRESENT;
}

public void clear() {
  map.clear();
}

很簡單對不對，就這麼幾個方法，並且你看每一個方法其實都是對應的操做 map，也就是內部的 HashMap，也就是說只要你懂了 HashMap天然也就懂了 HashSet。

保證不重複

Set接口要求不能有重複項，只要繼承了 Set就要遵照這個規定。咱們大多數狀況下使用 HashSet也是由於它有去重的功能。

那它是如何辦到的呢，這就要從它的 add方法提及了。

// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
public boolean add(E e) {
  return map.put(e, PRESENT)==null;
}

HashSet的 add方法其實就是調用了HashMap的put方法，可是咱們都知道 put進去的是一個鍵值對，可是 HashSet存的不是鍵值對啊，是一個泛型啊，那它是怎麼辦到的呢？

它把你要存的值當作 HashMap的 key，而 value 值是一個 final的Object對象，只起一個佔位做用。而HashMap自己就不容許重複鍵，正好被HashSet拿來即用。

如何保證不重複呢

HashMap中不容許存在相同的 key 的，那怎麼保證 key 的惟一性呢，判斷的代碼以下。

if (p.hash == hash &&
        ((k = p.key) == key || (key != null && key.equals(k))))

首先經過 hash 算法算出的值必須相等，算出的結果是 int，因此能夠用 == 符號判斷。只是這個條件可不行，要知道哈希碰撞是什麼意思，有可能兩個不同的 key 最後產生的 hash 值是相同的。

而且待插入的 key == 當前索引已存在的 key，或者 待插入的 key.equals(當前索引已存在的key)，注意== 和 equals 是或的關係。== 符號意味着這是同一個對象， equals 用來肯定兩個對象內容相同。

若是 key 是基本數據類型，好比 int，那相同的值確定是相等的，而且產生的 hashCode 也是一致的。

String 類型算是最經常使用的 key 類型了，咱們都知道相同的字符串產生的 hashCode 也是同樣的，而且字符串能夠用 equals 判斷相等。

可是若是用引用類型當作 key 呢，好比我定義了一個 MoonKey 做爲 key 值類型

public class MoonKey {

    private String keyTile;

    public String getKeyTile() {
        return keyTile;
    }

    public void setKeyTile(String keyTile) {
        this.keyTile = keyTile;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MoonKey moonKey = (MoonKey) o;
        return Objects.equals(keyTile, moonKey.keyTile);
    }
}

而後用下面的代碼進行兩次添加，你說 size 的長度是 1 仍是 2 呢？

Map<MoonKey, String> m = new HashMap<>();
MoonKey moonKey = new MoonKey();
moonKey.setKeyTile("1");
MoonKey moonKey1 = new MoonKey();
moonKey1.setKeyTile("1");
m.put(moonKey, "1");
m.put(moonKey1, "2");
System.out.println(hash(moonKey));
System.out.println(hash(moonKey1));
System.out.println(m.size());

答案是 2 ，爲何呢，由於 MoonKey 沒有重寫 hashCode 方法，致使 moonkey 和 moonKey1 的 hash 值不可能同樣，當不重寫 hashCode 方法時，默認繼承自 Object的 hashCode 方法，而每一個 Object對象的 hash 值都是獨一無二的。

劃重點，正確的作法應該是加上 hashCode的重寫。

@Override
public int hashCode() {
  return Objects.hash(keyTile);
}

這也是爲何要求重寫 equals 方法的同時，也必須重寫 hashCode方法的緣由之一。若是兩個對象經過調用equals方法是相等的，那麼這兩個對象調用hashCode方法必須返回相同的整數。有了這個基礎才能保證 HashMap或者HashSet的 key 惟一。

非線程安全

因爲HashMap不是線程安全的，天然，HashSet也不是線程安全啦。在多線程、高併發環境中慎用，若是要用的話怎麼辦呢，不像 HashMap那樣有多線程版本的ConcurrentHashMap，不存在 `ConcurrentHashSet這種數據結構，若是想用的話要用下面這種方式。

Set<String> set = Collections.synchronizedSet(new HashSet<String>());

或者使用 ConcurrentHashMap.KeySetView也能夠，可是，這其實就不是 HashSet了，而是 ConcurrentHashMap的一個實現了 Set接口的靜態內部類，多線程狀況下使用起來徹底沒問題。

ConcurrentHashMap.KeySetView<String,Boolean> keySetView = ConcurrentHashMap.newKeySet();
keySetView.add("a");
keySetView.add("b");
keySetView.add("c");
keySetView.add("a");
keySetView.forEach(System.out::println);

LinkedHashSet

若是說 HashSet是套殼兒HashMap，那麼LinkedHashSet就是套殼兒LinkedHashMap。對比 HashSet，它的一個特色就是保證數據有序，插入的時候什麼順序，遍歷的時候就是什麼順序。

看一下它其中的無參構造函數。

public LinkedHashSet() {
  super(16, .75f, true);
}

LinkedHashSet繼承自 HashSet，因此 super(16, .75f, true);是調用了HashSet三個參數的構造函數。

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
  map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

此次不是 new HashMap了，而是 new 了一個 LinkedHashMap，這就是它能保證有序性的關鍵。LinkedHashMap用雙向鏈表的方式在 HashMap的基礎上額外保存了鍵值對的插入順序。

HashMap中定義了下面這三個方法，這三個方法是在插入和刪除鍵值對的時候調用的方法，用來維護雙向鏈表，在LinkedHashMap中有具體的實現。

// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

因爲LinkedHashMap能夠保證鍵值對順序，因此，用來實現簡單的 LRU 緩存。

因此，若是你有場景既要保證元素無重複，又要保證元素有序，可使用 LinkedHashSet。

最後

其實你掌握了 HashMap就掌握了 HashSet，它沒有什麼新東西，就是巧妙的利用了 HashMap而已，新不新沒關係，好用纔是最重要的。

還能夠讀：

別說你還不懂 HashMap

有趣的圖說 HashMap，普通人也能看懂

跟我極速嚐鮮 Spring Boot 2.3

---

公衆號：古時的風箏

一個兼具深度與廣度的程序員鼓勵師，一個本打算寫詩卻寫起了代碼的田園碼農！你可選擇如今就關注我，或者看看歷史文章再關注也不遲。

技術交流還能夠加羣或者直接加我微信。