JAVA 基礎(chǔ) ：Set——你真的了解嗎污秆？
簡述
Set 繼承于 Collection 劈猪，是一種集合。有元素無序良拼、值不重復战得、不允許空值得特性。主要有HashSet庸推、TreeSet兩種實現(xiàn)方式常侦。由于Set主要基于Map實現(xiàn)，所以特點也由Map決定予弧。
Set 結(jié)構(gòu)圖
例如 HashSet ,調(diào)用 HashSet 的無參構(gòu)造函數(shù)刮吧，HashSet 會使用默認的 HashMap ，初始化 Size 為16掖蛤，擴張系數(shù)為0.75
HashSet
官方文檔
官方文檔翻譯
構(gòu)造方法官方文檔
構(gòu)造方法官方文檔翻譯
HashSet 結(jié)構(gòu)圖
查看 HashSet 源碼會發(fā)現(xiàn)主要數(shù)據(jù)操作都間接調(diào)用 HashMap 的數(shù)據(jù)操作杀捻，從 add() 方法可以看出 HashSet 的值其實為 HashMap 的 Key，而 Value 是一個關(guān)鍵字為 final 類型為 Object 的 PRESENT 蚓庭，遍歷的 HashSet 的值其實是遍歷 HashMap 的 KeyEntry .
HashSet 源碼
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable
{
static final long serialVersionUID = -5024744406713321676L;
private transient HashMap<E,Object> map;
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
/**
* Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
* default initial capacity (16) and load factor (0.75).
*/
public HashSet() {
map = new HashMap<>();
}
/**
* Constructs a new set containing the elements in the specified
* collection. The <tt>HashMap</tt> is created with default load factor
* (0.75) and an initial capacity sufficient to contain the elements in
* the specified collection.
*
* @param c the collection whose elements are to be placed into this set
* @throws NullPointerException if the specified collection is null
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
/**
* Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
* the specified initial capacity and the specified load factor.
*
* @param initialCapacity the initial capacity of the hash map
* @param loadFactor the load factor of the hash map
* @throws IllegalArgumentException if the initial capacity is less
* than zero, or if the load factor is nonpositive
*/
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
/**
* Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
* the specified initial capacity and default load factor (0.75).
*
* @param initialCapacity the initial capacity of the hash table
* @throws IllegalArgumentException if the initial capacity is less
* than zero
*/
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
/**
* Constructs a new, empty linked hash set. (This package private
* constructor is only used by LinkedHashSet.) The backing
* HashMap instance is a LinkedHashMap with the specified initial
* capacity and the specified load factor.
*
* @param initialCapacity the initial capacity of the hash map
* @param loadFactor the load factor of the hash map
* @param dummy ignored (distinguishes this
* constructor from other int, float constructor.)
* @throws IllegalArgumentException if the initial capacity is less
* than zero, or if the load factor is nonpositive
*/
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
/**
* Returns an iterator over the elements in this set. The elements
* are returned in no particular order.
*
* @return an Iterator over the elements in this set
* @see ConcurrentModificationException
*/
public Iterator<E> iterator() {
return map.keySet().iterator();
}
/**
* Returns the number of elements in this set (its cardinality).
*
* @return the number of elements in this set (its cardinality)
*/
public int size() {
return map.size();
}
/**
* Returns <tt>true</tt> if this set contains no elements.
*
* @return <tt>true</tt> if this set contains no elements
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* Returns <tt>true</tt> if this set contains the specified element.
* More formally, returns <tt>true</tt> if and only if this set
* contains an element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>.
*
* @param o element whose presence in this set is to be tested
* @return <tt>true</tt> if this set contains the specified element
*/
public boolean contains(Object o) {
return map.containsKey(o);
}
/**
* Adds the specified element to this set if it is not already present.
* More formally, adds the specified element <tt>e</tt> to this set if
* this set contains no element <tt>e2</tt> such that
* <tt>(e==null ? e2==null : e.equals(e2))</tt>.
* If this set already contains the element, the call leaves the set
* unchanged and returns <tt>false</tt>.
*
* @param e element to be added to this set
* @return <tt>true</tt> if this set did not already contain the specified
* element
*/
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
/**
* Removes the specified element from this set if it is present.
* More formally, removes an element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>,
* if this set contains such an element. Returns <tt>true</tt> if
* this set contained the element (or equivalently, if this set
* changed as a result of the call). (This set will not contain the
* element once the call returns.)
*
* @param o object to be removed from this set, if present
* @return <tt>true</tt> if the set contained the specified element
*/
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
/**
* Removes all of the elements from this set.
* The set will be empty after this call returns.
*/
public void clear() {
map.clear();
}
/**
* Returns a shallow copy of this <tt>HashSet</tt> instance: the elements
* themselves are not cloned.
*
* @return a shallow copy of this set
*/
@SuppressWarnings("unchecked")
public Object clone() {
try {
HashSet<E> newSet = (HashSet<E>) super.clone();
newSet.map = (HashMap<E, Object>) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
/**
* Save the state of this <tt>HashSet</tt> instance to a stream (that is,
* serialize it).
*
* @serialData The capacity of the backing <tt>HashMap</tt> instance
* (int), and its load factor (float) are emitted, followed by
* the size of the set (the number of elements it contains)
* (int), followed by all of its elements (each an Object) in
* no particular order.
*/
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);
}
/**
* Reconstitute the <tt>HashSet</tt> instance from a stream (that is,
* deserialize it).
*/
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);
}
// Set the capacity according to the size and load factor ensuring that
// the HashMap is at least 25% full but clamping to maximum capacity.
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);
}
}
/**
* Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>
* and <em>fail-fast</em> {@link Spliterator} over the elements in this
* set.
*
* <p>The {@code Spliterator} reports {@link Spliterator#SIZED} and
* {@link Spliterator#DISTINCT}. Overriding implementations should document
* the reporting of additional characteristic values.
*
* @return a {@code Spliterator} over the elements in this set
* @since 1.8
*/
public Spliterator<E> spliterator() {
return new HashMap.KeySpliterator<E,Object>(map, 0, -1, 0, 0);
}
}
TreeSet
TreeSet 和 HashSet 實現(xiàn)類似致讥，間接調(diào)用內(nèi)部的 TreeMap ，都是利用紅黑樹算法實現(xiàn)器赞；TreeSet 會根據(jù)其元素的自然順序?qū)υ剡M行排序,元素依然是唯一的不可重復垢袱，元素不可為 null .
TreeSet 結(jié)構(gòu)圖
LinkedHashSet
介于 HashSet 與 TreeSet 之間，在 HashSet 的基礎(chǔ)上增加了一個記錄插入順序的雙鏈表港柜。線程不安全有序不重復集合请契，基于 LinkedHashMap 實現(xiàn)咳榜，是 HashMap 與雙向鏈表結(jié)合實現(xiàn)的，利用雙向鏈表記錄插入順序爽锥，以保證迭代輸出的有序性涌韩。
LinkedHashSet 結(jié)構(gòu)圖
ConcurrentSkipListSet
線程安全的有序不重復集合，適用于高并發(fā)場景氯夷；與 TreeSet 對比臣樱，相同點是都是有序集合，不同點有兩方面腮考，第一 TreeSet 是非線程安全的雇毫，第二 ConcurrentSkipListSet 是基于 ConcurrentSkipListMap 通過跳表數(shù)據(jù)結(jié)構(gòu)實現(xiàn)而 TreeSet 是基于 TreeMap 通過紅黑樹算法實現(xiàn)。
ConcurrentSkipListSet 結(jié)構(gòu)圖
CopyOnWriteArraySet
線程安全的無序不重復集合踩蔚，適用于高并發(fā)場景棚放；與 HashSet 對比，相同點是都是無序集合寂纪，不同點有有兩個席吴，第一 HashSet 是非線程安全的，第二 CopyOnWriteArraySet 是基于 CopyOnWriteArrayList 通過動態(tài)數(shù)組數(shù)據(jù)結(jié)構(gòu)實現(xiàn)而 HashSet 是基于 HashMap 通過散列表數(shù)據(jù)結(jié)構(gòu)實現(xiàn)捞蛋。
CopyOnWriteArraySet 結(jié)構(gòu)圖
EnumSet
Set針對枚舉類型的接口實現(xiàn)類；通過位向量實現(xiàn)柬姚；EnumSet 中所有元素都必須是指定的枚舉類型或枚舉值拟杉，由 EnumSet 創(chuàng)建時指定，集合元素為有序量承、不重復搬设、非 null ，元素的順序與枚舉類元素順序相同撕捍；
EnumSet 結(jié)構(gòu)圖
JobStateReasons
JobStateReasons 結(jié)構(gòu)圖
ConcurrentHashMap.KeySetView
KeySetView 結(jié)構(gòu)圖
如有寫的不對的地方請大家指正拿穴，萬分感謝，相互學習忧风，相互交流
