HashSet怎么保證元素不重復(fù)

小編給大家分享一下HashSet怎么保證元素不重復(fù)，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

HashSet 實(shí)現(xiàn)了 Set 接口，由哈希表（實(shí)際是 HashMap）提供支持。HashSet 不保證集合的迭代順序，但允許插入 null 值。也就是說(shuō) HashSet 不能保證元素插入順序和迭代順序相同。
HashSet 具備去重的特性，也就是說(shuō)它可以將集合中的重復(fù)元素自動(dòng)過(guò)濾掉，保證存儲(chǔ)在 HashSet 中的元素都是唯一的。

1.HashSet 基本用法

HashSet 基本操作方法有：add（添加）、remove（刪除）、contains（判斷某個(gè)元素是否存在）和 size（集合數(shù)量）。這些方法的性能都是固定操作時(shí)間，如果哈希函數(shù)是將元素分散在桶中的正確位置。
HashSet 基本使用如下：

// 創(chuàng)建 HashSet 集合
HashSet<String> strSet = new HashSet<>();
// 給 HashSet 添加數(shù)據(jù)
strSet.add("Java");
strSet.add("MySQL");
strSet.add("Redis");
// 循環(huán)打印 HashSet 中的所有元素
strSet.forEach(s -> System.out.println(s));

2.HashSet 無(wú)序性

HashSet 不能保證插入元素的順序和循環(huán)輸出元素的順序一定相同，也就是說(shuō) HashSet 其實(shí)是無(wú)序的集合，具體代碼示例如下：

HashSet<String> mapSet = new HashSet<>();
mapSet.add("深圳");
mapSet.add("北京");
mapSet.add("西安");
// 循環(huán)打印 HashSet 中的所有元素
mapSet.forEach(m -> System.out.println(m));

以上程序的執(zhí)行結(jié)果如下：

從上述代碼和執(zhí)行結(jié)果可以看出，HashSet 插入的順序是：深圳 -> 北京 -> 西安，而循環(huán)打印的順序卻是：西安 -> 深圳 -> 北京，所以 HashSet 是無(wú)序的，不能保證插入和迭代的順序一致。

PS：如果要保證插入順序和迭代順序一致，可使用 LinkedHashSet 來(lái)替換 HashSet。

3.HashSet 錯(cuò)誤用法

有人說(shuō) HashSet 只能保證基礎(chǔ)數(shù)據(jù)類型不重復(fù)，卻不能保證自定義對(duì)象不重復(fù)？這樣說(shuō)對(duì)嗎？
我們通過(guò)以下示例來(lái)說(shuō)明此問(wèn)題。

3.1 HashSet 與基本數(shù)據(jù)類型

使用 HashSet 存儲(chǔ)基本數(shù)據(jù)類型，實(shí)現(xiàn)代碼如下：

HashSet<Long> longSet = new HashSet<>();
longSet.add(666l);
longSet.add(777l);
longSet.add(999l);
longSet.add(666l);
// 循環(huán)打印 HashSet 中的所有元素
longSet.forEach(l -> System.out.println(l));

以上程序的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，使用 HashSet 可以保證基礎(chǔ)數(shù)據(jù)類型不重復(fù)。

3.2 HashSet 與自定義對(duì)象類型

接下來(lái)，將自定義對(duì)象存儲(chǔ)到 HashSet 中，實(shí)現(xiàn)代碼如下：

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<Person> personSet = new HashSet<>();
        personSet.add(new Person("曹操", "123"));
        personSet.add(new Person("孫權(quán)", "123"));
        personSet.add(new Person("曹操", "123"));
        // 循環(huán)打印 HashSet 中的所有元素
        personSet.forEach(p -> System.out.println(p));
    }
}
@Getter
@Setter
@ToString
class Person {
    private String name;
    private String password;

    public Person(String name, String password) {
        this.name = name;
        this.password = password;
    }
}

以上程序的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，自定義對(duì)象類型確實(shí)沒(méi)有被去重，那也就是說(shuō) HashSet 不能實(shí)現(xiàn)自定義對(duì)象類型的去重咯？
其實(shí)并不是，HashSet 去重功能是依賴元素的 hashCode 和 equals 方法判斷的，通過(guò)這兩個(gè)方法返回的都是 true 那就是相同對(duì)象，否則就是不同對(duì)象。而前面的 Long 類型元素之所以能實(shí)現(xiàn)去重，正是因?yàn)?Long 類型中已經(jīng)重寫(xiě)了 hashCode 和 equals 方法，具體實(shí)現(xiàn)源碼如下：

@Override
public int hashCode() {
    return Long.hashCode(value);
}
public boolean equals(Object obj) {
    if (obj instanceof Long) {
        return value == ((Long)obj).longValue();
    }
    return false;
}
//省略其他源碼......

更多關(guān)于 hashCode 和 equals 的內(nèi)容，詳見(jiàn)：http://www.kemok4.com/article/204554.htm

那么，想讓 HashSet 支持自定義對(duì)象去重，只需要在自定義對(duì)象中重寫(xiě) hashCode 和 equals 方法即可，具體實(shí)現(xiàn)代碼如下：

@Setter
@Getter
@ToString
class Person {
    private String name;
    private String password;
    public Person(String name, String password) {
        this.name = name;
        this.password = password;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true; // 引用相等返回 true
        // 如果等于 null，或者對(duì)象類型不同返回 false
        if (o == null || getClass() != o.getClass()) return false;
        // 強(qiáng)轉(zhuǎn)為自定義 Person 類型
        Person persion = (Person) o;
        // 如果 name 和 password 都相等，就返回 true
        return Objects.equals(name, persion.name) &&
                Objects.equals(password, persion.password);
    }
    @Override
    public int hashCode() {
        // 對(duì)比 name 和 password 是否相等
        return Objects.hash(name, password);
    }
}

重新運(yùn)行以上代碼，執(zhí)行結(jié)果如下圖所示：

從上述結(jié)果可以看出，之前的重復(fù)項(xiàng)“曹操”已經(jīng)被去重了。

4.HashSet 如何保證元素不重復(fù)？

我們只要了解了 HashSet 執(zhí)行添加元素的流程，就能知道為什么 HashSet 能保證元素不重復(fù)了？
HashSet 添加元素的執(zhí)行流程是：當(dāng)把對(duì)象加入 HashSet 時(shí)，HashSet 會(huì)先計(jì)算對(duì)象的 hashcode 值來(lái)判斷對(duì)象加入的位置，同時(shí)也會(huì)與其他加入的對(duì)象的 hashcode 值作比較，如果沒(méi)有相符的 hashcode，HashSet 會(huì)假設(shè)對(duì)象沒(méi)有重復(fù)出現(xiàn)，會(huì)將對(duì)象插入到相應(yīng)的位置中。但是如果發(fā)現(xiàn)有相同 hashcode 值的對(duì)象，這時(shí)會(huì)調(diào)用對(duì)象的 equals() 方法來(lái)檢查對(duì)象是否真的相同，如果相同，則 HashSet 就不會(huì)讓重復(fù)的對(duì)象加入到 HashSet 中，這樣就保證了元素的不重復(fù)。

為了更清楚的了解 HashSet 的添加流程，我們可以嘗試閱讀 HashSet 的具體實(shí)現(xiàn)源碼，HashSet 添加方法的實(shí)現(xiàn)源碼如下（以下源碼基于 JDK 8）：

// hashmap 中 put() 返回 null 時(shí)，表示操作成功
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

從上述源碼可以看出 HashSet 中的 add 方法，實(shí)際調(diào)用的是 HashMap 中的 put，那么我們繼續(xù)看 HashMap 中的 put 實(shí)現(xiàn)：

// 返回值：如果插入位置沒(méi)有元素則返回 null，否則返回上一個(gè)元素
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

從上述源碼可以看出，HashMap 中的 put() 方法又調(diào)用了 putVal() 方法，putVal() 的源碼如下：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K, V>[] tab;
        Node<K, V> p;
        int n, i;
        //如果哈希表為空，調(diào)用 resize() 創(chuàng)建一個(gè)哈希表，并用變量 n 記錄哈希表長(zhǎng)度
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        /**
         * 如果指定參數(shù) hash 在表中沒(méi)有對(duì)應(yīng)的桶，即為沒(méi)有碰撞
         * Hash函數(shù)，(n - 1) & hash 計(jì)算 key 將被放置的槽位
         * (n - 1) & hash 本質(zhì)上是 hash % n 位運(yùn)算更快
         */
        if ((p = tab[i = (n - 1) & hash]) == null)
            // 直接將鍵值對(duì)插入到 map 中即可
            tab[i] = newNode(hash, key, value, null);
        else {// 桶中已經(jīng)存在元素
            Node<K, V> e;
            K k;
            // 比較桶中第一個(gè)元素(數(shù)組中的結(jié)點(diǎn))的 hash 值相等，key 相等
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                // 將第一個(gè)元素賦值給 e，用 e 來(lái)記錄
                e = p;
                // 當(dāng)前桶中無(wú)該鍵值對(duì)，且桶是紅黑樹(shù)結(jié)構(gòu)，按照紅黑樹(shù)結(jié)構(gòu)插入
            else if (p instanceof TreeNode)
                e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
                // 當(dāng)前桶中無(wú)該鍵值對(duì)，且桶是鏈表結(jié)構(gòu)，按照鏈表結(jié)構(gòu)插入到尾部
            else {
                for (int binCount = 0; ; ++binCount) {
                    // 遍歷到鏈表尾部
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 檢查鏈表長(zhǎng)度是否達(dá)到閾值，達(dá)到將該槽位節(jié)點(diǎn)組織形式轉(zhuǎn)為紅黑樹(shù)
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 鏈表節(jié)點(diǎn)的<key, value>與 put 操作<key, value>
                    // 相同時(shí)，不做重復(fù)操作，跳出循環(huán)
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // 找到或新建一個(gè) key 和 hashCode 與插入元素相等的鍵值對(duì)，進(jìn)行 put 操作
            if (e != null) { // existing mapping for key
                // 記錄 e 的 value
                V oldValue = e.value;
                /**
                 * onlyIfAbsent 為 false 或舊值為 null 時(shí)，允許替換舊值
                 * 否則無(wú)需替換
                 */
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                // 訪問(wèn)后回調(diào)
                afterNodeAccess(e);
                // 返回舊值
                return oldValue;
            }
        }
        // 更新結(jié)構(gòu)化修改信息
        ++modCount;
        // 鍵值對(duì)數(shù)目超過(guò)閾值時(shí)，進(jìn)行 rehash
        if (++size > threshold)
            resize();
        // 插入后回調(diào)
        afterNodeInsertion(evict);
        return null;
    }

從上述源碼可以看出，當(dāng)將一個(gè)鍵值對(duì)放入 HashMap 時(shí)，首先根據(jù) key 的 hashCode() 返回值決定該 Entry 的存儲(chǔ)位置。如果有兩個(gè) key 的 hash 值相同，則會(huì)判斷這兩個(gè)元素 key 的 equals() 是否相同，如果相同就返回 true，說(shuō)明是重復(fù)鍵值對(duì)，那么 HashSet 中 add() 方法的返回值會(huì)是 false，表示 HashSet 添加元素失敗。因此，如果向 HashSet 中添加一個(gè)已經(jīng)存在的元素，新添加的集合元素不會(huì)覆蓋已有元素，從而保證了元素的不重復(fù)。如果不是重復(fù)元素，put 方法最終會(huì)返回 null，傳遞到 HashSet 的 add 方法就是添加成功。

以上是“HashSet怎么保證元素不重復(fù)”這篇文章的所有內(nèi)容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內(nèi)容對(duì)大家有所幫助，如果還想學(xué)習(xí)更多知識(shí)，歡迎關(guān)注億速云行業(yè)資訊頻道！