Set源码解析

Set接口继承了Collection接口，继承了所有Collection接口的方法，下面予以分析Set源码。

package java.util;

/**
 * 不包含有重复元素的无序集合。通过.equals()方法校验是否重复
 */
public interface Set<E> extends Collection<E> {
    // Query Operations

    /**
     * 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)
     * 返回set中元素的数量
     * 如果元素数量大于2^31-1，返回的值为2^31-1
     */
    int size();

    /**
     * set集合是否为空，若为空，则返回true
     *               若不为空，则返回false
     */
    boolean isEmpty();

    /**
     * set集合是否包含元素o,若包含，返回true;否则返回false
     */
    boolean contains(Object o);

    /**
     * 返回set集合的迭代器
     */
    Iterator<E> iterator();

    /**
     * 将set集合转化为数组
     */
    Object[] toArray();

    /**
     * Returns an array containing all of the elements in this set; the
     * runtime type of the returned array is that of the specified array.
     * If the set fits in the specified array, it is returned therein.
     * Otherwise, a new array is allocated with the runtime type of the
     * specified array and the size of this set.
     *
     * <p>If this set fits in the specified array with room to spare
     * (i.e., the array has more elements than this set), the element in
     * the array immediately following the end of the set is set to
     * <tt>null</tt>.  (This is useful in determining the length of this
     * set <i>only</i> if the caller knows that this set does not contain
     * any null elements.)
     *
     * <p>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.
     *
     * <p>Like the {@link #toArray()} method, this method acts as bridge between
     * array-based and collection-based APIs.  Further, this method allows
     * precise control over the runtime type of the output array, and may,
     * under certain circumstances, be used to save allocation costs.
     *
     * <p>Suppose <tt>x</tt> is a set known to contain only strings.
     * The following code can be used to dump the set into a newly allocated
     * array of <tt>String</tt>:
     *
     * <pre>
     *     String[] y = x.toArray(new String[0]);</pre>
     *
     * Note that <tt>toArray(new Object[0])</tt> is identical in function to
     * <tt>toArray()</tt>.
     *
     * @param a the array into which the elements of this set are to be
     *        stored, if it is big enough; otherwise, a new array of the same
     *        runtime type is allocated for this purpose.
     * @return an array containing all the elements in this set
     * @throws ArrayStoreException if the runtime type of the specified array
     *         is not a supertype of the runtime type of every element in this
     *         set
     * @throws NullPointerException if the specified array is null
     */
    <T> T[] toArray(T[] a);


    // Modification Operations

    /**
     * 向set中添加元素e
     */
    boolean add(E e);


    /**
     * 移除元素o
     */
    boolean remove(Object o);


    // Bulk Operations

    /**
     * set是否包含c中所有元素
     */
    boolean containsAll(Collection<?> c);

    /**
     * 将c中所有元素添加到set中
     */
    boolean addAll(Collection<? extends E> c);

    /**
     * 保留c中所有元素
     */
    boolean retainAll(Collection<?> c);

    /**
     * 移除set中所有c的元素
     */
    boolean removeAll(Collection<?> c);

    /**
     * 移除所有set元素
     */
    void clear();


    // Comparison and hashing

    /**
     * 是否为同一对象
     */
    boolean equals(Object o);

    /**
     * 获取set的hash值
     */
    int hashCode();
}