快捷導(dǎo)航

Java中的Set集合源碼詳細(xì)解讀

更新時(shí)間：2023年11月15日 10:35:33 作者：緣之妙不可言

這篇文章主要介紹了Java中的Set集合源碼詳細(xì)解讀,Set注重獨(dú)一無(wú)二的性質(zhì),該體系集合用于存儲(chǔ)無(wú)序(存入和取出的順序不一定相同)元素, 值不能重復(fù),需要的朋友可以參考下

Set集合

Set注重獨(dú)一無(wú)二的性質(zhì)，該體系集合用于存儲(chǔ)無(wú)序(存入和取出的順序不一定相同)元素, 值不能重復(fù)。

對(duì)象的相等性本質(zhì)是對(duì)象hashCode值(java 是依據(jù)對(duì)象的內(nèi)存地址計(jì)算出的此序號(hào))判斷的(去重)，如果想要讓兩個(gè)不同的對(duì)象視為相等的，就必須覆蓋Object的hashCode方法和equals方法。

HashSet,(一張hash表)

哈希表邊存放的是哈希值。HashSet 存儲(chǔ)元素的順序并不是按照存入時(shí)的順序(和List顯然不同)而是按照哈希值來(lái)存的所以取數(shù)據(jù)也是按照哈希值取得。元素的哈希值是通過(guò)元素的hashCode方法來(lái)獲取的, **HashSet首先判斷兩個(gè)元素的哈希值，如果哈希值一樣，接著會(huì)比較equals方法如果equals結(jié)果為true，HashSet 就視為同一個(gè)元素。**如果equals為false就不是同一個(gè)元素。哈希值相同equals為false的元素存儲(chǔ)：在同樣的哈希值下順延(可以認(rèn)為哈希值相同的元素放在一個(gè)哈希桶中)。也就是哈希一樣的存一列

TreeSet（二叉樹）

TreeSet()是使用二叉樹的原理對(duì)新add)的對(duì)象按照指定的順序排序(升序、降序)，每增加一個(gè)對(duì)象都會(huì)進(jìn)行排序，將對(duì)象插入的二叉樹指定的位置。
Integer 和String對(duì)象都可以進(jìn)行默認(rèn)的TreeSet排序,而自定義類的對(duì)象是不可以的，自己定義的類必須實(shí)現(xiàn)Comparable接口,并且覆寫相應(yīng)的compareTo)函數(shù)，才可以正常使用
在覆寫 compare()函數(shù)時(shí),要返回相應(yīng)的值才能使TreeSet按照一定的規(guī)則來(lái)排序。
比較此對(duì)象與指定對(duì)象的順序。如果該對(duì)象小于、等于或大于指定對(duì)象，則分別返回負(fù)整數(shù)、零或正整數(shù)。

LinkHashSet (HashSet+ LinkedHashMap)

對(duì)于LinkedHashSet 而言，它繼承與HashSet、又基于LinkedHashMap 來(lái)實(shí)現(xiàn)的。

LinkedHashSet底層使用LinkedHashMap來(lái)保存所有元素，它繼承與HashSet,其所有的方法操作_上又與HashSet相同，因此LinkedHashSet的實(shí)現(xiàn)上非常簡(jiǎn)單，只提供了四個(gè)構(gòu)造方法，并通過(guò)傳遞-一個(gè)標(biāo)識(shí)參數(shù)，調(diào)用父類的構(gòu)造器，底層構(gòu)造-個(gè)LinkedHashMap 來(lái)實(shí)現(xiàn)，在相關(guān)操作.上與父類HashSet的操作相同，直接調(diào)用父類HashSet的方法即可。

HashSet源碼

Set是基于HashMap實(shí)現(xiàn)的，源碼主要體現(xiàn)的是它的獨(dú)一無(wú)二，不可重復(fù)性

HashSet構(gòu)造方法（4個(gè)）就是新建一個(gè)HashMap（參考HashMap的構(gòu)造，共四個(gè)）

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

我們?cè)倏匆幌鹿俜筋愖⑨專?/p>

此類實(shí)現(xiàn)Set接口，支持由哈希表（實(shí)際上是一個(gè)HashMap實(shí)例）。它不保證為向集合的迭代順序; 特別是，它不保證該順序恒久不變。此類允許null元素。
這個(gè)類提供了基本操作（添加，刪除，包含和大小），假定哈希函數(shù)將恒定的時(shí)間性能分散的元素正確的桶中。遍歷該集合需要時(shí)間正比于HashSet實(shí)例的大小（元素的數(shù)量）加上其底層HashMap實(shí)例的“容量”（桶的數(shù)量）的總和。因此，不要將初始容量設(shè)置得太高（或負(fù)載因數(shù)過(guò)低），如果迭代性能很重要，非常重要。
注意，此實(shí)現(xiàn)不是同步的。如果多個(gè)線程同時(shí)訪問(wèn)一個(gè)散列集，螺紋修改的和至少一個(gè)設(shè)定的，它必須被外部同步。這通常是通過(guò)一些對(duì)象自然封裝該組同步操作來(lái)完成。如果該對(duì)象不存在，該組應(yīng)該被“包裝”使用Collections.synchronizedSet方法。這最好在創(chuàng)建時(shí)完成，以防止對(duì)set的意外非同步訪問(wèn)：
Set s = Collections.synchronizedSet(new HashSet(...));
此類的iterator方法返回的迭代器是快速失敗的：如果集合隨時(shí)修改創(chuàng)建迭代器之后，以任何方式除非通過(guò)迭代器自身的remove方法，迭代器將拋出ConcurrentModificationException 。因此，在并發(fā)的修改，迭代器很快就會(huì)完全失敗，而不是在將來(lái)不確定的時(shí)間任意冒險(xiǎn)，不確定性的行為。
注意的迭代器無(wú)法保證，因?yàn)?，一般?lái)說(shuō)快速失敗行為，不可能作出任何硬性保證不同步并發(fā)修改的存在。快速失敗的迭代器拋出ConcurrentModificationException盡最大努力的基礎(chǔ)上。因此，這將是錯(cuò)誤的，寫一個(gè)程序，依賴于此異常的它的正確性：迭代器的快速失敗行為應(yīng)該僅用于檢測(cè)bug。
這個(gè)類是成員的Java集合框架

闡述關(guān)鍵：

元素?zé)o序
允許null元素
迭代時(shí)允許快速失敗，既是線程不安全的（繼承的HashMap的內(nèi)容），就是不能在迭代時(shí)被其它線程以任何形式修改結(jié)構(gòu)，這幾乎是所有集合的保護(hù)機(jī)制（Vector除外）（不懂可自行百度）

HashSet集合不少源碼都得在HashMap中才看得到, 源碼中還有一些多的功能：例如序列化與反序列化：

	//序列化
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // Write out any hidden serialization magic
        s.defaultWriteObject();

        // Write out HashMap capacity and load factor
        s.writeInt(map.capacity());
        s.writeFloat(map.loadFactor());

        // Write out size
        s.writeInt(map.size());

        // Write out all elements in the proper order.
        for (E e : map.keySet())
            s.writeObject(e);
    }

    /**
    反序列化
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();

        // Read capacity and verify non-negative.
        int capacity = s.readInt();
        if (capacity < 0) {
            throw new InvalidObjectException("Illegal capacity: " +
                                             capacity);
        }

        // Read load factor and verify positive and non NaN.
        float loadFactor = s.readFloat();
        if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
            throw new InvalidObjectException("Illegal load factor: " +
                                             loadFactor);
        }

        // Read size and verify non-negative.
        int size = s.readInt();
        if (size < 0) {
            throw new InvalidObjectException("Illegal size: " +
                                             size);
        }

   
        capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f),
                HashMap.MAXIMUM_CAPACITY);

        // Create backing HashMap
        map = (((HashSet<?>)this) instanceof LinkedHashSet ?
               new LinkedHashMap<E,Object>(capacity, loadFactor) :
               new HashMap<E,Object>(capacity, loadFactor));

        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            @SuppressWarnings("unchecked")
                E e = (E) s.readObject();
            map.put(e, PRESENT);
        }
    }