Collection里面有什么？

- 日理万妓 2022-08-29 09:47 176阅读 0赞

Collection：专为引用变量设计的集合

# Collection里面有什么 #

## 1. 常用操作 ##

### size方法 ###

> 统计元素的数量

返回这个集合里面的元素数量，如果这个集合包含了超过 {
        @code Integer.MAX_VALUE} ，返回{
        @code Integer.MAX_VALUE} 。
    
    int size();

### isEmpty() ###

判断这个集合是否没有元素包含在内。
    
    boolean isEmpty();

### contains(Object o) ###

如果这个集合包含了指定的（specified）元素，返回true；
    更加正式地说，返回正确当且仅当集合至少含有一个这样的元素。
        
    boolean contains(Object o);

### iterator（） ###

> 遍历集合的一种方式，迭代器**依赖于集合存在**。
> 
> 继承了这个方法的都可以进行foreach操作。

返回一个基于此集合中元素的迭代器。
 但是它不保证返回的顺序，除非某个类能够保证它的返回顺序。
 @return 一个 {@code Iterator} 基于这个元素的集合
 
 Iterator<E> iterator();

### toArray(); ###

/**
 * 返回一个包含所有元素的数组
 * 如果这个集合能够保证迭代器返回的顺序，那么这个方法必须以相同的顺序返回。
 * 
 * 返回数组的 {@linkplain Class#getComponentType runtime component type} is {@code Object}.
 *
 * The returned array will be "safe" in that no references to it are
 * maintained by this collection. (In other words, this method must
 * allocate a new array even if this collection is backed by an array).
 * The caller is thus free to modify the returned array.
 *
 * @apiNote
 * This method acts as a bridge between array-based and collection-based APIs.
 * It returns an array whose runtime type is {@code Object[]}.
 * Use {@link #toArray(Object[]) toArray(T[])} to reuse an existing
 * array, or use {@link #toArray(IntFunction)} to control the runtime type
 * of the array.
 *
 * @return an array, whose {@linkplain Class#getComponentType runtime component
 * type} is {@code Object}, containing all of the elements in this collection
 */
 Object[] toArray();

### toArray(T\[\] a); ###

/**
 * Returns an array containing all of the elements in this collection;
 * the runtime type of the returned array is that of the specified array.
 * If the collection 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 collection.
 *
 * If this collection fits in the specified array with room to spare
 * (i.e., the array has more elements than this collection), the element
 * in the array immediately following the end of the collection is set to
 * {@code null}. (This is useful in determining the length of this
 * collection only if the caller knows that this collection does
 * not contain any {@code null} elements.)
 *
 * If this collection makes any guarantees as to what order its elements
 * are returned by its iterator, this method must return the elements in
 * the same order.
 *
 * @apiNote
 * This method acts as a bridge between array-based and collection-based APIs.
 * It allows an existing array to be reused under certain circumstances.
 * Use {@link #toArray()} to create an array whose runtime type is {@code Object[]},
 * or use {@link #toArray(IntFunction)} to control the runtime type of
 * the array.
 *
 * Suppose {@code x} is a collection known to contain only strings.
 * The following code can be used to dump the collection into a previously
 * allocated {@code String} array:
 *
 * <pre>
 * String[] y = new String[SIZE];
 * ...
 * y = x.toArray(y);</pre>
 *
 * The return value is reassigned to the variable {@code y}, because a
 * new array will be allocated and returned if the collection {@code x} has
 * too many elements to fit into the existing array {@code y}.
 *
 * Note that {@code toArray(new Object[0])} is identical in function to
 * {@code toArray()}.
 *
 * @param <T> the component type of the array to contain the collection
 * @param a the array into which the elements of this collection 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 of the elements in this collection
 * @throws ArrayStoreException if the runtime type of any element in this
 * collection is not assignable to the {@linkplain Class#getComponentType
 * runtime component type} of the specified array
 * @throws NullPointerException if the specified array is null
 */
 <T> T[] toArray(T[] a);

### add(E e); ###

> 添加一个元素

/**
 * 确保集合包含了指定的元素 (optional operation). 
 * Returns {@code true} 如果这个集合确实是经过调用而改变了。
 * Returns {@code false} 如果这个集合不允许重复并且已经存在的元素。
 *
 * Collections that support this operation may place limitations on what
 * elements may be added to this collection. In particular, some
 * collections will refuse to add {@code null} elements, and others will
 * impose restrictions on the type of elements that may be added.
 * Collection classes should clearly specify in their documentation any
 * restrictions on what elements may be added.
 *
 * If a collection refuses to add a particular element for any reason
 * other than that it already contains the element, it must throw
 * an exception (rather than returning {@code false}). This preserves
 * the invariant that a collection always contains the specified element
 * after this call returns.
 *
 * @param e element whose presence in this collection is to be ensured
 * @return {@code true} if this collection changed as a result of the
 * call
 * @throws UnsupportedOperationException if the {@code add} operation
 * is not supported by this collection
 * @throws ClassCastException if the class of the specified element
 * prevents it from being added to this collection
 * @throws NullPointerException if the specified element is null and this
 * collection does not permit null elements
 * @throws IllegalArgumentException if some property of the element
 * prevents it from being added to this collection
 * @throws IllegalStateException if the element cannot be added at this
 * time due to insertion restrictions
 */
 boolean add(E e);

### remove(Object o); ###

> 移除一个元素

/**
 * Removes a single instance of the specified element from this
 * collection, if it is present (optional operation). More formally,
 * removes an element {@code e} such that
 * {@code Objects.equals(o, e)}, if
 * this collection contains one or more such elements. Returns
 * {@code true} if this collection contained the specified element (or
 * equivalently, if this collection changed as a result of the call).
 *
 * @param o element to be removed from this collection, if present
 * @return {@code true} if an element was removed as a result of this call
 * @throws ClassCastException if the type of the specified element
 * is incompatible with this collection
 * (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if the specified element is null and this
 * collection does not permit null elements
 * (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws UnsupportedOperationException if the {@code remove} operation
 * is not supported by this collection
 */
 boolean remove(Object o);

## 2. 批量操作： ##

### addAll(Collection c ) ###

> 添加一个集合的元素

/**
 * Adds all of the elements in the specified collection to this collection
 * (optional operation). The behavior of this operation is undefined if
 * the specified collection is modified while the operation is in progress.
 * (This implies that the behavior of this call is undefined if the
 * specified collection is this collection, and this collection is
 * nonempty.)
 *
 * @param c collection containing elements to be added to this collection
 * @return {@code true} if this collection changed as a result of the call
 * @throws UnsupportedOperationException if the {@code addAll} operation
 * is not supported by this collection
 * @throws ClassCastException if the class of an element of the specified
 * collection prevents it from being added to this collection
 * @throws NullPointerException if the specified collection contains a
 * null element and this collection 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
 * collection
 * @throws IllegalStateException if not all the elements can be added at
 * this time due to insertion restrictions
 * @see #add(Object)
 */
 boolean addAll(Collection<? extends E> c);

### removeAll(); ###

> 移除一个集合的元素，只要一个元素被移除了，就返回true下

/**
 * Removes all of this collection's elements that are also contained in the
 * specified collection (optional operation). After this call returns,
 * this collection will contain no elements in common with the specified
 * collection.
 *
 * @param c collection containing elements to be removed from this collection
 * @return {@code true} if this collection changed as a result of the
 * call
 * @throws UnsupportedOperationException if the {@code removeAll} method
 * is not supported by this collection
 * @throws ClassCastException if the types of one or more elements
 * in this collection are incompatible with the specified
 * collection
 * (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if this collection contains one or more
 * null elements and the specified collection does not support
 * null elements
 * (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>),
 * or if the specified collection is null
 * @see #remove(Object)
 * @see #contains(Object)
 */
 boolean removeAll(Collection<?> c);

### clear(); ###

> 移除所有元素

/**
     * Removes all of the elements from this collection (optional operation).
     * The collection will be empty after this method returns.
     *
     * @throws UnsupportedOperationException if the {@code clear} operation
     *         is not supported by this collection
     */
    void clear();

### retainAll（Collection c） ###

> 移除池collection中未包含在指定的collection中的而所有元素。
> 
> 集合A和集合B做交集，最终的结果保存在集合A，返回值表示的是A是否发生过变化。

/**
 * Retains only the elements in this collection that are contained in the
 * specified collection (optional operation). In other words, removes from
 * this collection all of its elements that are not contained in the
 * specified collection.
 *
 * @param c collection containing elements to be retained in this collection
 * @return {@code true} if this collection changed as a result of the call
 * @throws UnsupportedOperationException if the {@code retainAll} operation
 * is not supported by this collection
 * @throws ClassCastException if the types of one or more elements
 * in this collection are incompatible with the specified
 * collection
 * (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>)
 * @throws NullPointerException if this collection contains one or more
 * null elements and the specified collection does not permit null
 * elements
 * (<a href="{@docRoot}/java.base/java/util/Collection.html#optional-restrictions">optional</a>),
 * or if the specified collection is null
 * @see #remove(Object)
 * @see #contains(Object)
 */
 boolean retainAll(Collection<?> c);

## 3. 比较和散列 ##

> Comparison and hashing

### equals ###

/**
 * Compares the specified object with this collection for equality. 
 *
 * While the {@code Collection} interface adds no stipulations to the
 * general contract for the {@code Object.equals}, programmers who
 * implement the {@code Collection} interface "directly" (in other words,
 * create a class that is a {@code Collection} but is not a {@code Set}
 * or a {@code List}) must exercise care if they choose to override the
 * {@code Object.equals}. It is not necessary to do so, and the simplest
 * course of action is to rely on {@code Object}'s implementation, but
 * the implementor may wish to implement a "value comparison" in place of
 * the default "reference comparison." (The {@code List} and
 * {@code Set} interfaces mandate such value comparisons.)
 *
 * The general contract for the {@code Object.equals} method states that
 * equals must be symmetric (in other words, {@code a.equals(b)} if and
 * only if {@code b.equals(a)}). The contracts for {@code List.equals}
 * and {@code Set.equals} state that lists are only equal to other lists,
 * and sets to other sets. Thus, a custom {@code equals} method for a
 * collection class that implements neither the {@code List} nor
 * {@code Set} interface must return {@code false} when this collection
 * is compared to any list or set. (By the same logic, it is not possible
 * to write a class that correctly implements both the {@code Set} and
 * {@code List} interfaces.)
 *
 * @param o object to be compared for equality with this collection
 * @return {@code true} if the specified object is equal to this
 * collection
 *
 * @see Object#equals(Object)
 * @see Set#equals(Object)
 * @see List#equals(Object)
 */
 boolean equals(Object o);

### hashCode(); ###

/**
     * Returns the hash code value for this collection.  While the
     * {@code Collection} interface adds no stipulations to the general
     * contract for the {@code Object.hashCode} method, programmers should
     * take note that any class that overrides the {@code Object.equals}
     * method must also override the {@code Object.hashCode} method in order
     * to satisfy the general contract for the {@code Object.hashCode} method.
     * In particular, {@code c1.equals(c2)} implies that
     * {@code c1.hashCode()==c2.hashCode()}.
     *
     * @return the hash code value for this collection
     *
     * @see Object#hashCode()
     * @see Object#equals(Object)
     */
    int hashCode();

# Collection下面有什么？ #

Collection下面还有List和Set

List下面有

*  ArrayList：动态数组（底层数据结构），线程不安全
 *  LinkedList：链表（底层数据结构），线程不安全
 *  vector：动态数组（底层数据结构），线程安全

Set下面有：

*  HashSet：哈希表（以元素为链表）
 *  TreeSet：红黑树（自平衡二叉树，自然排序）保证了元素的排列方式。
 *  LinkedHashSet：哈希表和链表 》 哈希表和红黑树