Java中的Set集合源碼詳細解讀

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

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

Set集合

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

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

HashSet,(一張hash表)

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

TreeSet（二叉樹）

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

LinkHashSet (HashSet+ LinkedHashMap)

對于LinkedHashSet 而言，它繼承與HashSet、又基于LinkedHashMap 來實現(xiàn)的。

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

HashSet源碼

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

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

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

我們再看一下官方類注釋：

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

闡述關(guān)鍵：

元素無序
允許null元素
迭代時允許快速失敗，既是線程不安全的（繼承的HashMap的內(nèi)容），就是不能在迭代時被其它線程以任何形式修改結(jié)構(gòu)，這幾乎是所有集合的保護機制（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);
        }
    }