JAVA集合源码攻坚战（11）—— Set
前言正文声明的方法查询操作size()isEmpty()contains(Object o)iterator()toArray()
修改操作boolean add(E e);boolean remove(Object o);
批量操作boolean containsAll(Collection<?> c);boolean addAll(Collection<? extends E> c);boolean retainAll(Collection<?> c);boolean removeAll(Collection<?> c);void clear();
比较与hash操作boolean equals(Object o);int hashCode();
前言
好，今天开始学Set，你说为什么？没有为什么！！W(￣_￣)W
正文
Set是直接继承了Collection的一个接口，对Set这一些列的集合进行了一个总的定义。 Set集合类与List最大的区别是，Set集合不支持重复元素，并且如果允许null元素的实现类，也最多只能包含一个null元素。 定义的方法如下图：
声明的方法
查询操作
size()
/**返回当前set中的元素的数量（它的基数）。
* 如果该set包含的元素个数超过Integer.MAX_VALUE，则返回Integer.MAX_VALUE。
* Returns the number of elements in this set (its cardinality). If this
* set contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
* <tt>Integer.MAX_VALUE</tt>.
*
* @return the number of elements in this set (its cardinality)
*/
int size();
isEmpty()
/**
* 如果当前set没有任何元素，则返回true。
* Returns <tt>true</tt> if this set contains no elements.
*
* @return <tt>true</tt> if this set contains no elements
*/
boolean isEmpty();
contains(Object o)
/**
* 如果该set中包含指定元素，则返回true。
* 更正式的，当且仅当（o==null?e==null:o.equals(e)）的情况下，才返回true。
* 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
* @throws ClassCastException if the type of the specified element
* is incompatible with this set
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if the specified element is null and this
* set does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>)
*/
boolean contains(Object o);
iterator()
/**
* 返回该set集合的迭代器。
* 返回的元素是无序的（除非这个set是一些做了特别处理的来的集合实例）。
* Returns an iterator over the elements in this set. The elements are
* returned in no particular order (unless this set is an instance of some
* class that provides a guarantee).
*
* @return an iterator over the elements in this set
*/
Iterator<E> iterator();
toArray()
/**
* 返回一个数组，它包含了集合中的所有元素。
* 如果这个set保证了调用迭代器返回的元素按照特定的顺序来返回，那么该方法
* 也必须保证转为数组后，顺序也要一致。
* Returns an array containing all of the elements in this set.
* If this set makes any guarantees as to what order its elements
* are returned by its iterator, this method must return the
* elements in the same order.
*
* 返回的数组是安全的，与原来的set没有任何关系。
* 换言之，调用该方法的时候，需要分配一个新的数组空间来存放数据，那么即使改变了数组元素或set元素，
* 都不会影响另外一个。
* <p>The returned array will be "safe" in that no references to it
* are maintained by this set. (In other words, this method must
* allocate a new array even if this set is backed by an array).
* The caller is thus free to modify the returned array.
*
* <p>This method acts as bridge between array-based and collection-based
* APIs.
*
* @return an array containing all the elements in this set
*/
Object[] toArray();
修改操作
boolean add(E e);
/**
* 添加指定元素到该set集合中。更通畅的，该方法添加的元素e，应该是集合中找不到一个元素e2，
* 能符合（e==null ? e2==null : e.equals(e2)）的。
* 如果集合中已有该元素，则set集合保持不变，并且返回false。
* 结合对构造器的限制，该方法保证了set集合不会包含重复元素。
* Adds the specified element to this set if it is not already present
* (optional operation). More formally, adds the specified element
* <tt>e</tt> to this set if the 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>. In combination with the
* restriction on constructors, this ensures that sets never contain
* duplicate elements.
*
* 上面的规定并不意味着集合必须接受所有元素。
* set集合可能会拒绝添加一些特别的元素，比如null，会抛出异常。
* set的实现类应该清晰的给出对能包含元素的一个限制的文档。
* <p>The stipulation above does not imply that sets must accept all
* elements; sets may refuse to add any particular element, including
* <tt>null</tt>, and throw an exception, as described in the
* specification for {@link Collection#add Collection.add}.
* Individual set implementations should clearly document any
* restrictions on the elements that they may contain.
*
* @param e element to be added to this set
* @return <tt>true</tt> if this set did not already contain the specified
* element
* @throws UnsupportedOperationException if the <tt>add</tt> operation
* is not supported by this set
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this set
* @throws NullPointerException if the specified element is null and this
* set does not permit null elements
* @throws IllegalArgumentException if some property of the specified element
* prevents it from being added to this set
*/
boolean add(E e);
boolean remove(Object o);
/**
* 从set集合中移除指定元素。如果该集合包含该元素，则会返回true。
* Removes the specified element from this set if it is present
* (optional operation). 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 this set contained the specified element
* @throws ClassCastException if the type of the specified element
* is incompatible with this set
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if the specified element is null and this
* set does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws UnsupportedOperationException if the <tt>remove</tt> operation
* is not supported by this set
*/
boolean remove(Object o);
批量操作
boolean containsAll(Collection<?> c);
/**
* 判断当前set是否包含了指定集合中的所有元素。
* 如果指定集合也是一个set，并且是当前set的一个子集，则返回true。
* Returns <tt>true</tt> if this set contains all of the elements of the
* specified collection. If the specified collection is also a set, this
* method returns <tt>true</tt> if it is a <i>subset</i> of this set.
*
* @param c collection to be checked for containment in this set
* @return <tt>true</tt> if this set contains all of the elements of the
* specified collection
* @throws ClassCastException if the types of one or more elements
* in the specified collection are incompatible with this
* set
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if the specified collection contains one
* or more null elements and this set does not permit null
* elements
* (<a href="Collection.html#optional-restrictions">optional</a>),
* or if the specified collection is null
* @see #contains(Object)
*/
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
/**
* 将指定集合中的所有元素添加到当前集合中，重复元素不添加。
* 如果指定集合也是set集合，则操作效率更高，得到的集合是两个集合的一个并集。
* 如果指定集合在操作的过程中被修改了，那么该方法的行为是不可预知的。
* Adds all of the elements in the specified collection to this set if
* they're not already present (optional operation). If the specified
* collection is also a set, the <tt>addAll</tt> operation effectively
* modifies this set so that its value is the <i>union</i> of the two
* sets. The behavior of this operation is undefined if the specified
* collection is modified while the operation is in progress.
*
* @param c collection containing elements to be added to this set
* @return <tt>true</tt> if this set changed as a result of the call
*
* @throws UnsupportedOperationException if the <tt>addAll</tt> operation
* is not supported by this set
* @throws ClassCastException if the class of an element of the
* specified collection prevents it from being added to this set
* @throws NullPointerException if the specified collection contains one
* or more null elements and this set does not permit null
* elements, or if the specified collection is null
* @throws IllegalArgumentException if some property of an element of the
* specified collection prevents it from being added to this set
* @see #add(Object)
*/
boolean addAll(Collection<? extends E> c);
boolean retainAll(Collection<?> c);
/**
* 对当前set集合和指定集合进行一个并集操作，只保留共有的元素。
* Retains only the elements in this set that are contained in the
* specified collection (optional operation). In other words, removes
* from this set all of its elements that are not contained in the
* specified collection. If the specified collection is also a set, this
* operation effectively modifies this set so that its value is the
* <i>intersection</i> of the two sets.
*
* @param c collection containing elements to be retained in this set
* @return <tt>true</tt> if this set changed as a result of the call
* @throws UnsupportedOperationException if the <tt>retainAll</tt> operation
* is not supported by this set
* @throws ClassCastException if the class of an element of this set
* is incompatible with the specified collection
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if this set contains a null element and the
* specified collection does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>),
* or if the specified collection is null
* @see #remove(Object)
*/
boolean retainAll(Collection<?> c);
boolean removeAll(Collection<?> c);
/**
* 移除当前集合中所有包括在指定集合中的元素。
* Removes from this set all of its elements that are contained in the
* specified collection (optional operation). If the specified
* collection is also a set, this operation effectively modifies this
* set so that its value is the <i>asymmetric set difference</i> of
* the two sets.
*
* @param c collection containing elements to be removed from this set
* @return <tt>true</tt> if this set changed as a result of the call
* @throws UnsupportedOperationException if the <tt>removeAll</tt> operation
* is not supported by this set
* @throws ClassCastException if the class of an element of this set
* is incompatible with the specified collection
* (<a href="Collection.html#optional-restrictions">optional</a>)
* @throws NullPointerException if this set contains a null element and the
* specified collection does not permit null elements
* (<a href="Collection.html#optional-restrictions">optional</a>),
* or if the specified collection is null
* @see #remove(Object)
* @see #contains(Object)
*/
boolean removeAll(Collection<?> c);
void clear();
/**
* 移除集合中的所有元素。调用该方法后，集合为空。
* Removes all of the elements from this set (optional operation).
* The set will be empty after this call returns.
*
* @throws UnsupportedOperationException if the <tt>clear</tt> method
* is not supported by this set
*/
void clear();
比较与hash操作
boolean equals(Object o);
/**
* 比较指定的对象与该set是否相等。
* 如果指定的对象也是set集合，并且两个set的size相等，且内部元素都一样，则返回true。
* 此定义确保equals方法在set接口的不同实现之间正常工作。
* Compares the specified object with this set for equality. Returns
* <tt>true</tt> if the specified object is also a set, the two sets
* have the same size, and every member of the specified set is
* contained in this set (or equivalently, every member of this set is
* contained in the specified set). This definition ensures that the
* equals method works properly across different implementations of the
* set interface.
*
* @param o object to be compared for equality with this set
* @return <tt>true</tt> if the specified object is equal to this set
*/
boolean equals(Object o);
int hashCode();
/**
* 返回该set的哈希值。set的哈希值被定义为set中的元素的哈希值的和，其中null元素的哈希值
* 应该被定义为0。
* 这保证了如果s1.equals(s2)，那么必定sq.hashCode() == s2.hashCode()。
* Returns the hash code value for this set. The hash code of a set is
* defined to be the sum of the hash codes of the elements in the set,
* where the hash code of a <tt>null</tt> element is defined to be zero.
* This ensures that <tt>s1.equals(s2)</tt> implies that
* <tt>s1.hashCode()==s2.hashCode()</tt> for any two sets <tt>s1</tt>
* and <tt>s2</tt>, as required by the general contract of
* {@link Object#hashCode}.
*
* @return the hash code value for this set
* @see Object#equals(Object)
* @see Set#equals(Object)
*/
int hashCode();
