java keysetview,Set——你真的了解吗？
JAVA 基礎 ：Set——你真的了解嗎？
簡述
Set 繼承于 Collection ，是一種集合。有元素無序、值不重復、不允許空值得特性。主要有HashSet、TreeSet兩種實現方式。由于Set主要基于Map實現，所以特點也由Map決定。
Set 結構圖
例如 HashSet ,調用 HashSet 的無參構造函數，HashSet 會使用默認的 HashMap ，初始化 Size 為16，擴張系數為0.75
HashSet
官方文檔
官方文檔翻譯
構造方法官方文檔
構造方法官方文檔翻譯
HashSet 結構圖
查看 HashSet 源碼會發現主要數據操作都間接調用 HashMap 的數據操作，從 add() 方法可以看出 HashSet 的值其實為 HashMap 的 Key，而 Value 是一個關鍵字為 final 類型為 Object 的 PRESENT ，遍歷的 HashSet 的值其實是遍歷 HashMap 的 KeyEntry .
HashSet 源碼
public class HashSet
extends AbstractSet
implements Set, Cloneable, java.io.Serializable
{
static final long serialVersionUID = -5024744406713321676L;
private transient HashMap 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 HashMap 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 HashMap 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 HashMap 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 HashMap 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 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 true if this set contains no elements.
*
* @return true if this set contains no elements
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* Returns true if this set contains the specified element.
* More formally, returns true if and only if this set
* contains an element e such that
* (o==null???e==null?:?o.equals(e)).
*
* @param o element whose presence in this set is to be tested
* @return true 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 e to this set if
* this set contains no element e2 such that
* (e==null???e2==null?:?e.equals(e2)).
* If this set already contains the element, the call leaves the set
* unchanged and returns false.
*
* @param e element to be added to this set
* @return true 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 e such that
* (o==null???e==null?:?o.equals(e)),
* if this set contains such an element. Returns true 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 true 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 HashSet instance: the elements
* themselves are not cloned.
*
* @return a shallow copy of this set
*/
@SuppressWarnings("unchecked")
public Object clone() {
try {
HashSet newSet = (HashSet) super.clone();
newSet.map = (HashMap) map.clone();
return newSet;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
/**
* Save the state of this HashSet instance to a stream (that is,
* serialize it).
*
* @serialData The capacity of the backing HashMap 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 HashSet 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(capacity, loadFactor) :
new HashMap(capacity, loadFactor));
// Read in all elements in the proper order.
for (int i=0; i
@SuppressWarnings("unchecked")
E e = (E) s.readObject();
map.put(e, PRESENT);
}
}
/**
* Creates a late-binding
* and fail-fast {@link Spliterator} over the elements in this
* set.
*
*
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 spliterator() {
return new HashMap.KeySpliterator(map, 0, -1, 0, 0);
}
}
TreeSet
TreeSet 和 HashSet 實現類似，間接調用內部的 TreeMap ，都是利用紅黑樹算法實現；TreeSet 會根據其元素的自然順序對元素進行排序,元素依然是唯一的不可重復，元素不可為 null .
TreeSet 結構圖
LinkedHashSet
介于 HashSet 與 TreeSet 之間，在 HashSet 的基礎上增加了一個記錄插入順序的雙鏈表。線程不安全有序不重復集合，基于 LinkedHashMap 實現，是 HashMap 與雙向鏈表結合實現的，利用雙向鏈表記錄插入順序，以保證迭代輸出的有序性。
LinkedHashSet 結構圖
ConcurrentSkipListSet
線程安全的有序不重復集合，適用于高并發場景；與 TreeSet 對比，相同點是都是有序集合，不同點有兩方面，第一 TreeSet 是非線程安全的，第二 ConcurrentSkipListSet 是基于 ConcurrentSkipListMap 通過跳表數據結構實現而 TreeSet 是基于 TreeMap 通過紅黑樹算法實現。
ConcurrentSkipListSet 結構圖
CopyOnWriteArraySet
線程安全的無序不重復集合，適用于高并發場景；與 HashSet 對比，相同點是都是無序集合，不同點有有兩個，第一 HashSet 是非線程安全的，第二 CopyOnWriteArraySet 是基于 CopyOnWriteArrayList 通過動態數組數據結構實現而 HashSet 是基于 HashMap 通過散列表數據結構實現。
CopyOnWriteArraySet 結構圖
EnumSet
Set針對枚舉類型的接口實現類；通過位向量實現；EnumSet 中所有元素都必須是指定的枚舉類型或枚舉值，由 EnumSet 創建時指定，集合元素為有序、不重復、非 null ，元素的順序與枚舉類元素順序相同；
EnumSet 結構圖
JobStateReasons
JobStateReasons 結構圖
ConcurrentHashMap.KeySetView
KeySetView 結構圖
如有寫的不對的地方請大家指正，萬分感謝，相互學習，相互交流
總結
以上是生活随笔為你收集整理的java keysetview,Set——你真的了解吗？的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 怎么获得问道手游无上尊者称号？
- 下一篇： 有什么办法可以缩胸